From e9c7aa28cd5f5fdc1aa11b18f344d4fe3ea67d8b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 3 Jul 2025 16:22:54 +0200 Subject: [PATCH 001/114] Obtain more code coverage --- README.md | 2 +- .../boost/multiprecision/cpp_dec_float.hpp | 28 +- .../boost/multiprecision/cpp_double_fp.hpp | 60 ++-- .../multiprecision/detail/default_ops.hpp | 9 +- test/test_exp.cpp | 3 +- test/test_log.cpp | 4 +- test/test_various_edges.cpp | 178 +++++++++++- test/test_various_edges_more.cpp | 256 ++++++++++++++++-- 8 files changed, 458 insertions(+), 82 deletions(-) diff --git a/README.md b/README.md index b1051d734..f76b58810 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ requiring extended range and precision. Multiprecision consists of a generic interface to the mathematics of large numbers as well as a selection of big number backends. -This includes interfaces to GMP, MPFR, MPIR and TomMath +These include interfaces to GMP, MPFR, MPIR and TomMath and also Multiprecision's own collection of Boost-licensed, header-only backends for integers, rationals, floats and complex-floats. diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index c9b958c06..df1a173bd 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -427,7 +427,6 @@ class cpp_dec_float cpp_dec_float& div_unsigned_long_long(const unsigned long long n); // Elementary primitives. - cpp_dec_float& calculate_inv(); cpp_dec_float& calculate_sqrt(); void negate() @@ -568,6 +567,9 @@ class cpp_dec_float static bool data_elem_is_non_nine_predicate(const std::uint32_t& d) { return (d != static_cast(cpp_dec_float::cpp_dec_float_elem_mask - 1)); } static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast('0')); } + // Inversion. + cpp_dec_float& calculate_inv(); + void from_unsigned_long_long(const unsigned long long u); template & cpp_dec_float cpp_dec_float& cpp_dec_float::calculate_inv() { - // Compute the inverse of *this. - const bool b_neg = neg; - - neg = false; - - // Handle special cases like zero, inf and NaN. + // Handle the special case of zero. if (iszero()) { *this = inf(); - if (b_neg) - negate(); + return *this; } + // Handle the special cases of inf and NaN. + if ((isnan)()) { return *this; @@ -1242,14 +1240,12 @@ cpp_dec_float& cpp_dec_float x(*this); // Generate the initial estimate using division. diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 4e8245f18..9049e0bcc 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -163,9 +163,11 @@ struct number_category> : pub namespace backends { -// A cpp_double_fp_backend is represented by an unevaluated sum of two floating-point -// units (say a0 and a1) which satisfy |a1| <= (1 / 2) * ulp(a0). +// A cpp_double_fp_backend is represented by an unevaluated sum of two +// floating-point units, a0 and a1, which satisfy |a1| <= (1 / 2) * ulp(a0). // The type of the floating-point constituents should adhere to IEEE754. +// This class has been tested with floats having single-precision (4 byte), +// double-precision (8 byte) and quad precision (16 byte, such as GCC's __float128). template class cpp_double_fp_backend @@ -178,10 +180,10 @@ class cpp_double_fp_backend cpp_df_qf_detail::is_floating_point::value && bool { - (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24) - || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53) - || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64) - || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113) + ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 24) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) + || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 53) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) + || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 64) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) + || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113) }, "Error: float_type does not fulfil the backend requirements of cpp_double_fp_backend" ); @@ -514,12 +516,10 @@ class cpp_double_fp_backend } } - const float_type xlo { data.second }; + const rep_type thi_tlo { arithmetic::two_sum(data.second, v.data.second) }; data = arithmetic::two_sum(data.first, v.data.first); - const rep_type thi_tlo { arithmetic::two_sum(xlo, v.data.second) }; - data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); @@ -578,12 +578,10 @@ class cpp_double_fp_backend return *this; } - const float_type xlo { data.second }; + const rep_type thi_tlo { arithmetic::two_diff(data.second, v.data.second) }; data = arithmetic::two_diff(data.first, v.data.first); - const rep_type thi_tlo { arithmetic::two_diff(xlo, v.data.second) }; - data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); @@ -993,7 +991,8 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_eps_constexpr { - cpp_df_qf_detail::ccmath::unsafe::ldexp(float_type { 1 }, int { 3 - my_digits }) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + * cpp_double_fp_backend(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) }; static_assert @@ -1613,13 +1612,15 @@ template ::value && ((cpp_df_qf_detail::ccmath::numeric_limits::digits10 * 2) < 16))>::type const*> constexpr auto eval_exp(cpp_double_fp_backend& result, const cpp_double_fp_backend& x) -> void { - const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + constexpr double_float_type one { 1 }; + + const int fpc { eval_fpclassify(x) }; + if (fpc == FP_ZERO) { - result = double_float_type { 1.0F }; + result = one; } else if (fpc != FP_NORMAL) { @@ -1751,7 +1752,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (b_neg) { - result = double_float_type(1U) / result; + result = one / result; } } } @@ -1761,13 +1762,15 @@ template ::value && (((cpp_df_qf_detail::ccmath::numeric_limits::digits10 * 2) >= 16) && ((cpp_df_qf_detail::ccmath::numeric_limits::digits10 * 2) <= 36)))>::type const*> constexpr auto eval_exp(cpp_double_fp_backend& result, const cpp_double_fp_backend& x) -> void { - const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + constexpr double_float_type one { 1 }; + + const int fpc { eval_fpclassify(x) }; + if (fpc == FP_ZERO) { - result = double_float_type(1); + result = one; } else if (fpc != FP_NORMAL) { @@ -1901,7 +1904,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (b_neg) { - result = double_float_type(1U) / result; + result = one / result; } } } @@ -1911,13 +1914,15 @@ template ::value && ((cpp_df_qf_detail::ccmath::numeric_limits::digits10 * 2) > 36))>::type const*> constexpr auto eval_exp(cpp_double_fp_backend& result, const cpp_double_fp_backend& x) -> void { - const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + constexpr double_float_type one { 1 }; + + const int fpc { eval_fpclassify(x) }; + if (fpc == FP_ZERO) { - result = double_float_type(1); + result = one; } else if (fpc != FP_NORMAL) { @@ -2012,16 +2017,17 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const // Series expansion of hypergeometric_0f0(; ; x). // For this high(er) digit count, a scaled argument with subsequent // Taylor series expansion is actually more precise than Pade approximation. - for (unsigned n = 2U; n < 64U; ++n) + for (unsigned n { 2U }; n < 64U; ++n) { x_pow_n_div_n_fact *= xh; + x_pow_n_div_n_fact /= typename double_float_type::float_type(n); int n_tol { }; eval_frexp(dummy, x_pow_n_div_n_fact, &n_tol); - if ((n > 4U) && (n_tol < -(double_float_type::my_digits - 4))) + if ((n > 4U) && (n_tol < -(double_float_type::my_digits - 2))) { break; } @@ -2051,7 +2057,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (b_neg) { - result = double_float_type(1U) / result; + result = one / result; } } } diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index d66fe4a16..6e1aeb354 100644 --- a/include/boost/multiprecision/detail/default_ops.hpp +++ b/include/boost/multiprecision/detail/default_ops.hpp @@ -499,7 +499,7 @@ inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_same::va T t; t = number::canonical_value(u); return t; -} +} // LCOV_EXCL_LINE template inline BOOST_MP_CXX14_CONSTEXPR const T& make_T(const T& t) { @@ -1803,6 +1803,9 @@ BOOST_MP_CXX14_CONSTEXPR void eval_karatsuba_sqrt(Backend& result, const Backend result = s; } +// LCOV_EXCL_START +// This is known tested in the test-file test_various_edges.cpp. + template void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) { @@ -1861,6 +1864,8 @@ void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) } while (g >= 0); } +// LCOV_EXCL_STOP + template BOOST_MP_CXX14_CONSTEXPR void eval_integer_sqrt(Backend& result, Backend& r, const Backend& x) { @@ -3867,7 +3872,7 @@ conj(const number& arg) using default_ops::eval_conj; eval_conj(result.backend(), arg.backend()); return result; -} +} // LCOV_EXCL_LINE template inline BOOST_MP_CXX14_CONSTEXPR detail::expression< diff --git a/test/test_exp.cpp b/test/test_exp.cpp index 776b6e395..6cc7f1d16 100644 --- a/test/test_exp.cpp +++ b/test/test_exp.cpp @@ -14,8 +14,9 @@ #pragma warning(disable : 4127) #endif +#include + #include -#include "test.hpp" #include #include diff --git a/test/test_log.cpp b/test/test_log.cpp index 3860dbdf3..87ada4634 100644 --- a/test/test_log.cpp +++ b/test/test_log.cpp @@ -13,9 +13,11 @@ #define _SCL_SECURE_NO_WARNINGS #endif +#include + #include + #include -#include "test.hpp" #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DOUBLE_FLOAT) #define TEST_MPF_50 diff --git a/test/test_various_edges.cpp b/test/test_various_edges.cpp index 9db4378cb..03363efc7 100644 --- a/test/test_various_edges.cpp +++ b/test/test_various_edges.cpp @@ -28,10 +28,7 @@ #include #include -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wfloat-equal" -#elif defined(__GNUC__) +#if (defined(__clang__) || defined(__GNUC__)) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wfloat-equal" #endif @@ -97,13 +94,13 @@ namespace local { delta = fabs(a - b); // LCOV_EXCL_LINE - result_is_ok = (delta < tol); // LCOV_EXCL_LINE + result_is_ok = (delta <= tol); // LCOV_EXCL_LINE } else { delta = fabs(1 - (a / b)); - result_is_ok = (delta < tol); + result_is_ok = (delta <= tol); } return result_is_ok; @@ -501,6 +498,103 @@ namespace local return result_is_ok; } + template + auto test_fdim_edge() -> bool + { + using float_type = FloatType; + + std::mt19937_64 gen { time_point() }; + + std::uniform_real_distribution + dist + ( + static_cast(-125.5L), + static_cast(+125.5L) + ); + + auto result_is_ok = true; + + for(auto i = static_cast(UINT8_C(0)); i < static_cast(UINT8_C(4)); ++i) + { + static_cast(i); + + const float_type val_nrm = ::my_one() * static_cast(dist(gen)); + const float_type val_nan = std::numeric_limits::quiet_NaN() * static_cast(dist(gen)); + const float_type val_inf = std::numeric_limits::infinity() * static_cast(dist(gen)); + + const double flt_nrm = static_cast(val_nrm); + const double flt_nan = std::numeric_limits::quiet_NaN() * static_cast(dist(gen)); + const double flt_inf = std::numeric_limits::infinity() * static_cast(dist(gen)); + + using std::fdim; + using std::fpclassify; + + float_type result_fdim { fdim(val_nrm, val_nan) }; + bool result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_nrm, val_inf); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_nan, val_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_inf, val_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_INFINITE); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + // MP-type argument-a mixed with built-in argument-b. + result_fdim = fdim(val_nrm, flt_nan); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_nrm, flt_inf); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_nan, flt_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(val_inf, flt_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_INFINITE); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + // Built-in argument-a mixed with MP-type argument-b. + result_fdim = fdim(flt_nrm, val_nan); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(flt_nrm, val_inf); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(flt_nan, val_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_ZERO); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + + result_fdim = fdim(flt_inf, val_nrm); + result_fdim_is_ok = (fpclassify(result_fdim) == FP_INFINITE); + BOOST_TEST(result_fdim_is_ok); + result_is_ok = (result_fdim_is_ok && result_is_ok); + } + + return result_is_ok; + } + template auto test_sqrt_edge() -> bool { @@ -1523,10 +1617,72 @@ namespace local return result_is_ok; } + + auto test_sqrt_integral_and_constexpr() -> void + { + { + // Select some pseudo-random integers + + // Table[N[Exp[Pi EulerGamma*m], 36], {m, 1, 301, 100}] + // 6.13111418242260482895474318171556018 632831453348 + // 3.47920348866883608793309754527486715 109524826009*10^79 + // 1.97433232450131483625758030703105499 465632954349*10^158 + // 1.12036796360599148200087404494586705 923184966483*10^237 + + // N[Sqrt[613111418242260482895474318171556018], 50] + // N[Sqrt[347920348866883608793309754527486715], 50] + // N[Sqrt[197433232450131483625758030703105499], 50] + // N[Sqrt[112036796360599148200087404494586705], 50] + + // 7.8301431547722068635982391629827009581580426009374*10^17 + // 5.8984773362867438315481181521503243715373594761667*10^17 + // 4.4433459515339505424085647442953457083310383400346*10^17 + // 3.3471898117764273004961506045440891118909367547368*10^17 + + // 783014315477220686 + // 589847733628674383 + // 444334595153395054 + // 334718981177642730 + + constexpr boost::multiprecision::uint128_t un0 = boost::multiprecision::uint128_t(UINT64_C(613111418242260482)) * boost::multiprecision::uint128_t(UINT64_C(1000000000000000000)) + boost::multiprecision::uint128_t(UINT64_C(895474318171556018)); + constexpr boost::multiprecision::uint128_t un1 = boost::multiprecision::uint128_t(UINT64_C(347920348866883608)) * boost::multiprecision::uint128_t(UINT64_C(1000000000000000000)) + boost::multiprecision::uint128_t(UINT64_C(793309754527486715)); + constexpr boost::multiprecision::uint128_t un2 = boost::multiprecision::uint128_t(UINT64_C(197433232450131483)) * boost::multiprecision::uint128_t(UINT64_C(1000000000000000000)) + boost::multiprecision::uint128_t(UINT64_C(625758030703105499)); + constexpr boost::multiprecision::uint128_t un3 = boost::multiprecision::uint128_t(UINT64_C(112036796360599148)) * boost::multiprecision::uint128_t(UINT64_C(1000000000000000000)) + boost::multiprecision::uint128_t(UINT64_C(200087404494586705)); + + constexpr boost::multiprecision::uint128_t sqrt_un0(sqrt(un0)); + constexpr boost::multiprecision::uint128_t sqrt_un1(sqrt(un1)); + constexpr boost::multiprecision::uint128_t sqrt_un2(sqrt(un2)); + constexpr boost::multiprecision::uint128_t sqrt_un3(sqrt(un3)); + + static_assert(static_cast(sqrt_un0) == UINT64_C(783014315477220686), "Error in constexpr integer square root"); + static_assert(static_cast(sqrt_un1) == UINT64_C(589847733628674383), "Error in constexpr integer square root"); + static_assert(static_cast(sqrt_un2) == UINT64_C(444334595153395054), "Error in constexpr integer square root"); + static_assert(static_cast(sqrt_un3) == UINT64_C(334718981177642730), "Error in constexpr integer square root"); + + static_assert(sqrt(boost::multiprecision::uint128_t(0)) == 0, "Error in constexpr integer square root"); + static_assert(sqrt(boost::multiprecision::uint128_t(1)) == 1, "Error in constexpr integer square root"); + static_assert(sqrt(boost::multiprecision::uint128_t(2)) == 1, "Error in constexpr integer square root"); + + // N[Sqrt[2^128 - 1], 50] + // 1.8446744073709551615999999999999999999972894945688*10^19 + static_assert(sqrt((std::numeric_limits::max)()) == boost::multiprecision::uint128_t(UINT64_C(18446744073709551615)), "Error in constexpr integer square root"); + + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("613111418242260482895474318171556018")) == boost::multiprecision::uint128_t(UINT64_C(783014315477220686))); + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("347920348866883608793309754527486715")) == boost::multiprecision::uint128_t(UINT64_C(589847733628674383))); + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("197433232450131483625758030703105499")) == boost::multiprecision::uint128_t(UINT64_C(444334595153395054))); + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("112036796360599148200087404494586705")) == boost::multiprecision::uint128_t(UINT64_C(334718981177642730))); + + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("0")) == boost::multiprecision::uint128_t(UINT8_C(0))); + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("1")) == boost::multiprecision::uint128_t(UINT8_C(1))); + BOOST_TEST(sqrt(boost::multiprecision::uint128_t("2")) == boost::multiprecision::uint128_t(UINT8_C(1))); + } + } } // namespace local auto main() -> int { + local::test_sqrt_integral_and_constexpr(); + #if defined(TEST_CPP_DOUBLE_FLOAT) { using float_type = boost::multiprecision::cpp_double_float; @@ -1535,6 +1691,7 @@ auto main() -> int static_cast(local::test_edges()); static_cast(local::test_edges_extra()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1549,6 +1706,7 @@ auto main() -> int static_cast(local::test_edges()); static_cast(local::test_edges_extra()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1563,6 +1721,7 @@ auto main() -> int static_cast(local::test_edges()); static_cast(local::test_edges_extra()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1580,6 +1739,7 @@ auto main() -> int std::cout << "Testing type: " << typeid(float_type).name() << std::endl; static_cast(local::test_edges()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1595,6 +1755,7 @@ auto main() -> int std::cout << "Testing type: " << typeid(float_type).name() << std::endl; static_cast(local::test_edges()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1610,6 +1771,7 @@ auto main() -> int std::cout << "Testing type: " << typeid(float_type).name() << std::endl; static_cast(local::test_edges()); + local::test_fdim_edge(); local::test_sqrt_edge(); local::test_exp_edge(); local::test_log_edge(); @@ -1626,8 +1788,6 @@ template auto my_inf () noexcept -> FloatType& { using float template auto my_nan () noexcept -> FloatType& { using float_type = FloatType; static float_type val_nan { std::numeric_limits::quiet_NaN() }; return val_nan; } template auto my_exp1() noexcept -> FloatType& { using float_type = FloatType; static float_type val_exp1 { "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921817413596629043572900334295260595630738132328627943490763233829880753195251019011573834187930702154089149934884167509244761460668082265" }; return val_exp1; } -#if defined(__clang__) -# pragma clang diagnostic pop -#elif defined(__GNUC__) +#if (defined(__clang__) || defined(__GNUC__)) # pragma GCC diagnostic pop #endif diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index a0b6257e3..e2a0191d2 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -5,8 +5,9 @@ // Some parts of this test file have been taken from the Boost.Decimal project. -#include #include +#include +#include #include // Note: include this AFTER the test-backends are defined @@ -17,10 +18,7 @@ #include #include -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wfloat-equal" -#elif defined(__GNUC__) +#if (defined(__clang__) || defined(__GNUC__)) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wfloat-equal" #endif @@ -74,13 +72,79 @@ namespace local { delta = fabs(a - b); // LCOV_EXCL_LINE - result_is_ok = (delta < tol); // LCOV_EXCL_LINE + result_is_ok = (delta <= tol); // LCOV_EXCL_LINE } else { delta = fabs(1 - (a / b)); - result_is_ok = (delta < tol); + result_is_ok = (delta <= tol); + } + + return result_is_ok; + } + + template + bool test_convert_and_back(const float epsilon_factor) + { + using any_float_type = AnyFloatType; + using other_float_type = OtherFloatType; + + std::mt19937_64 gen { time_point() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(-1.5F), + static_cast(1.5F) + }; + + bool result_is_ok { true }; + + for(int n_loop = static_cast(INT8_C(0)); n_loop < static_cast(INT8_C(64)); ++n_loop) + { + static_cast(n_loop); + + using string_data_array_type = std::array; + + // Table[N[Exp[Pi EulerGamma*m], 100], {m, 1, 41, 10}] + // 6.131114182422604828954743181715560166328314533478636289880930665602805209787080979043183175178343525 + // 4.601860472890328982970020344164597095017995523702194983334509372565826509463730150117899613177592949*10^8 + // 3.454041008184686240269652058630805927805404685705614002929256804267342980143530922708514273650048389*10^16 + // 2.592516517287682590319488890844344913780990651072642232646840608443538857001634005575916140667342752*10^24 + // 1.945877850460679347837790546862626024227287564971475316486097406542338497232351222296834286913627889*10^32 + + const string_data_array_type + float_number_strings + { + std::string("6.131114182422604828954743181715560166328314533478636289880930665602805209787080979043183175178343525"), + std::string("4.601860472890328982970020344164597095017995523702194983334509372565826509463730150117899613177592949E8"), + std::string("3.454041008184686240269652058630805927805404685705614002929256804267342980143530922708514273650048389E16"), + std::string("2.592516517287682590319488890844344913780990651072642232646840608443538857001634005575916140667342752E24"), + std::string("1.945877850460679347837790546862626024227287564971475316486097406542338497232351222296834286913627889E32") + }; + + for(std::size_t index { std::size_t { UINT8_C(0) }}; index < std::tuple_size::value; ++index) + { + const any_float_type start(any_float_type(float_number_strings[index]) * (dis(gen)* dis(gen))); + const other_float_type other(start); + const any_float_type backto(other); + + const bool + result_of_trip_is_ok + { + local::is_close_fraction + ( + start, + backto, + any_float_type(std::numeric_limits::epsilon() * epsilon_factor) + ) + }; + + BOOST_TEST(result_of_trip_is_ok); + + result_is_ok = (result_of_trip_is_ok && result_is_ok); + } } return result_is_ok; @@ -194,12 +258,15 @@ namespace local const std::string str_ctrl { str128_maker(flt_n128) }; const std::string str_n128 { str128_maker(static_cast(val_n128)) }; + // This test assumes that boost::int128_type is as wide or wider than signed long long. + // Consider using a a kind of if-constexpr to verify this "up front". + result_val_n128_is_ok = ( (str_n128 == str_ctrl) && ( - (!is_neg) ? (val_n128 > static_cast((std::numeric_limits::max)())) - : (val_n128 < static_cast((std::numeric_limits::max)())) + (!is_neg) ? (val_n128 >= static_cast((std::numeric_limits::max)())) + : (val_n128 <= static_cast((std::numeric_limits::max)())) ) ); @@ -291,6 +358,106 @@ namespace local result_is_ok = (result_funky_strings_is_ok && result_is_ok); } + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + float_type flt_nrm { ::my_one() * dis(gen) }; + + const bool is_neg { ((index & 1U) != 0U) }; + + if(is_neg) + { + flt_nrm = -flt_nrm; + } + + const float_type flt_zer { ::my_zero() * dis(gen) }; + + flt_nrm /= flt_zer; + + bool result_div_zero_is_ok { (boost::multiprecision::isinf)(flt_nrm) }; + + if(is_neg) + { + result_div_zero_is_ok = ((boost::multiprecision::signbit)(flt_nrm) && result_div_zero_is_ok); + } + + BOOST_TEST(result_div_zero_is_ok); + + result_is_ok = (result_div_zero_is_ok && result_is_ok); + } + } + + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + float_type flt_nrm { ::my_one() + 0.25F }; + float_type flt_one { ::my_one() + ::my_zero() * dis(gen) }; + + const bool is_neg { ((index & 1U) != 0U) }; + + if(is_neg) + { + flt_one = -flt_one; + } + + flt_nrm /= flt_one; + + bool result_div_one_is_ok { (is_neg ? (flt_nrm == -1.25F) : (flt_nrm == 1.25F)) }; + + BOOST_TEST(result_div_one_is_ok); + + result_is_ok = (result_div_one_is_ok && result_is_ok); + } + } + + constexpr unsigned max_index { 1024U }; + + { + using std::ldexp; + + float_type flt_near_min { ldexp((std::numeric_limits::min)(), +64) }; + + unsigned index { }; + + while((index < max_index) && (!((boost::multiprecision::fpclassify)(flt_near_min) == FP_ZERO))) + { + flt_near_min /= static_cast(0xDEADBEEF); + + ++index; + } + + const bool result_unf_is_ok { ((index > 1U) && (index < max_index)) }; + + BOOST_TEST(result_unf_is_ok); + + result_is_ok = (result_unf_is_ok && result_is_ok); + } + + { + using std::ldexp; + + float_type flt_near_min { ldexp((std::numeric_limits::min)(), +64) }; + + unsigned index { }; + + while((index < max_index) && (!((boost::multiprecision::fpclassify)(flt_near_min) == FP_ZERO))) + { + flt_near_min /= static_cast(100000000ULL - 3ULL); + + ++index; + } + + const bool result_unf_is_ok { ((index > 1U) && (index < max_index)) }; + + BOOST_TEST(result_unf_is_ok); + + result_is_ok = (result_unf_is_ok && result_is_ok); + } + { using std::ldexp; @@ -300,14 +467,14 @@ namespace local unsigned index { }; - while((index < 1024U) && (!(boost::multiprecision::isinf)(flt_near_max))) + while((index < max_index) && (!(boost::multiprecision::isinf)(flt_near_max))) { flt_near_max += (flt_less_near_max * dis(gen)); ++index; } - const bool result_ovf_is_ok { ((index > 1U) && (index < 1024U)) }; + const bool result_ovf_is_ok { ((index > 1U) && (index < max_index)) }; BOOST_TEST(result_ovf_is_ok); @@ -323,14 +490,14 @@ namespace local unsigned index { }; - while((index < 1024U) && (!(boost::multiprecision::isinf)(flt_near_lowest))) + while((index < max_index) && (!(boost::multiprecision::isinf)(flt_near_lowest))) { flt_near_lowest -= (flt_less_near_max * dis(gen)); ++index; } - const bool result_ovf_is_ok { ((index > 1U) && (index < 1024U)) && signbit(flt_near_lowest) }; + const bool result_ovf_is_ok { ((index > 1U) && (index < max_index)) && signbit(flt_near_lowest) }; BOOST_TEST(result_ovf_is_ok); @@ -346,14 +513,14 @@ namespace local unsigned index { }; - while((index < 1024U) && (!(boost::multiprecision::isinf)(flt_near_max))) + while((index < max_index) && (!(boost::multiprecision::isinf)(flt_near_max))) { flt_near_max *= static_cast(INT32_C(2)); ++index; } - const bool result_ovf_is_ok { ((index > 1U) && (index < 1024U)) }; + const bool result_ovf_is_ok { ((index > 1U) && (index < max_index)) }; BOOST_TEST(result_ovf_is_ok); @@ -387,21 +554,34 @@ namespace local { static_cast(index); - float_type flt_zero_numerator { ::my_zero() * dis(gen) }; - float_type flt_finite_numerator { ::my_one() * dis(gen) }; + float_type flt_zer_numerator { ::my_zero() * dis(gen) }; + float_type flt_nrm_numerator { ::my_one() * dis(gen) }; float_type flt_nan_numerator { ::my_nan() * dis(gen) }; + float_type flt_inf_numerator { ::my_inf() * dis(gen) }; - const float_type flt_infinite_result_neg { -flt_finite_numerator /= static_cast(INT8_C(0)) }; + const float_type flt_inf_result_neg_01 { -flt_nrm_numerator /= static_cast(INT8_C(0)) }; + const float_type flt_inf_result_neg_02 { -flt_inf_numerator *= static_cast(index + 2U) }; - const bool result_edge_00 { (boost::multiprecision::isnan)(flt_zero_numerator /= static_cast(INT8_C(0))) }; - const bool result_edge_01 { (boost::multiprecision::isinf)(flt_finite_numerator /= static_cast(INT8_C(0))) }; - const bool result_edge_02 { (boost::multiprecision::isinf)(flt_infinite_result_neg) && (boost::multiprecision::signbit)(flt_infinite_result_neg) }; + const bool result_edge_00 { (boost::multiprecision::isnan)(flt_zer_numerator /= static_cast(INT8_C(0))) }; + const bool result_edge_01 { (boost::multiprecision::isinf)(flt_nrm_numerator /= static_cast(INT8_C(0))) }; + const bool result_edge_02 { (boost::multiprecision::isinf)(flt_inf_result_neg_01) && (boost::multiprecision::signbit)(flt_inf_result_neg_01) }; const bool result_edge_03 { (boost::multiprecision::isnan)(flt_nan_numerator /= static_cast(index + 2U)) }; + const bool result_edge_04 { (boost::multiprecision::isnan)(flt_nan_numerator *= static_cast(index + 2U)) }; + const bool result_edge_05 { (boost::multiprecision::isnan)(flt_inf_numerator *= static_cast(0)) }; + const bool result_edge_06 { (boost::multiprecision::isinf)(flt_inf_result_neg_02) && (boost::multiprecision::signbit)(flt_inf_result_neg_02) }; const bool result_divs_are_ok { - (result_edge_00 && result_edge_01 && result_edge_02 && result_edge_03) + ( + result_edge_00 + && result_edge_01 + && result_edge_02 + && result_edge_03 + && result_edge_04 + && result_edge_05 + && result_edge_06 + ) }; BOOST_TEST(result_divs_are_ok); @@ -413,6 +593,23 @@ namespace local return result_is_ok; } + template + auto test_convert_and_back_caller(const float epsilon_factor = 0.0F) -> bool + { + using other_float_type = OtherFloatType; + + std::cout << "Testing type (in test_convert_and_back): " << typeid(other_float_type).name() << std::endl; + + const bool + result_of_trip_is_ok + { + local::test_convert_and_back(epsilon_factor) + }; + + BOOST_TEST(result_of_trip_is_ok); + + return result_of_trip_is_ok; + } } // namespace local auto main() -> int @@ -437,6 +634,17 @@ auto main() -> int static_cast(local::test_edges()); } + { + using big_bin_float_backend_type = boost::multiprecision::cpp_bin_float<512>; + using big_dec_float_backend_type = boost::multiprecision::cpp_dec_float<512>; + + using big_bin_float_type = boost::multiprecision::number; + using big_dec_float_type = boost::multiprecision::number; + + static_cast(local::test_convert_and_back_caller(0.25F)); + static_cast(local::test_convert_and_back_caller(0.50F)); + } + return boost::report_errors(); } @@ -445,8 +653,6 @@ template auto my_one () noexcept -> FloatType& { using float template auto my_inf () noexcept -> FloatType& { using float_type = FloatType; static float_type val_inf { std::numeric_limits::infinity() }; return val_inf; } template auto my_nan () noexcept -> FloatType& { using float_type = FloatType; static float_type val_nan { std::numeric_limits::quiet_NaN() }; return val_nan; } -#if defined(__clang__) -# pragma clang diagnostic pop -#elif defined(__GNUC__) +#if (defined(__clang__) || defined(__GNUC__)) # pragma GCC diagnostic pop #endif From 5b7c6767bf91c8d2baba6c36dcc73c7b7c2f5524 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 3 Jul 2025 19:09:10 +0200 Subject: [PATCH 002/114] Repair epsilon but still open for evolution --- .../boost/multiprecision/cpp_dec_float.hpp | 29 +++++++++++++++++-- .../boost/multiprecision/cpp_double_fp.hpp | 3 +- 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index df1a173bd..57584c0ea 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -446,6 +446,7 @@ class cpp_dec_float } bool isone() const; + bool isone_minus() const; bool isint() const; bool isneg() const { return neg; } @@ -1228,9 +1229,9 @@ cpp_dec_float& cpp_dec_float::isone() const return false; } +template +bool cpp_dec_float::isone_minus() const +{ + // Check if the value of *this is identically 1 or very close to 1. + + const bool is_negative_and_is_finite = (neg && (isfinite)()); + + if (is_negative_and_is_finite) + { + if ((data[0u] == static_cast(1u)) && (exp == static_cast(0))) + { + const typename array_type::const_iterator it_non_zero = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate); + return (it_non_zero == data.end()); + } + else if ((data[0u] == static_cast(cpp_dec_float_elem_mask - 1)) && (exp == static_cast(-cpp_dec_float_elem_digits10))) + { + const typename array_type::const_iterator it_non_nine = std::find_if(data.begin(), data.end(), data_elem_is_non_nine_predicate); + return (it_non_nine == data.end()); + } + } + + return false; +} + template bool cpp_dec_float::isint() const { diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 9049e0bcc..22b79b671 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -991,8 +991,7 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_eps_constexpr { - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) - * cpp_double_fp_backend(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + cpp_df_qf_detail::ccmath::unsafe::ldexp(float_type { 1 }, int { 3 - my_digits }) }; static_assert From b196bcccd384aa2855bfae63f49ec8aae0c0be82 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 3 Jul 2025 21:14:41 +0200 Subject: [PATCH 003/114] Rework some functions --- .../boost/multiprecision/cpp_dec_float.hpp | 66 ++++++++----------- 1 file changed, 29 insertions(+), 37 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 57584c0ea..9d8a30eac 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -445,8 +445,6 @@ class cpp_dec_float return ((fpclass == cpp_dec_float_finite) && (data[0u] == 0u)); } - bool isone() const; - bool isone_minus() const; bool isint() const; bool isneg() const { return neg; } @@ -571,6 +569,17 @@ class cpp_dec_float // Inversion. cpp_dec_float& calculate_inv(); + bool isone() const + { + bool b_neg; + + const bool result_one_is_ok = is_one_or_minus_one(&b_neg); + + return (result_one_is_ok && (!b_neg)); + } + + bool is_one_or_minus_one(bool* p_sign) const; + void from_unsigned_long_long(const unsigned long long u); template & cpp_dec_float& cpp_dec_float::compare(const cpp_dec_floa if (iszero()) { // The value of *this is zero and v is either zero or non-zero. - return (v.iszero() ? 0 - : (v.neg ? 1 : -1)); + return (v.iszero() ? 0 : (v.neg ? 1 : -1)); } else if (v.iszero()) { @@ -1456,47 +1465,30 @@ int cpp_dec_float::compare(const cpp_dec_floa } template -bool cpp_dec_float::isone() const +bool cpp_dec_float::is_one_or_minus_one(bool* p_sign) const { // Check if the value of *this is identically 1 or very close to 1. - const bool not_negative_and_is_finite = ((!neg) && (isfinite)()); + if(p_sign != nullptr) + *p_sign = neg; - if (not_negative_and_is_finite) + if ((isfinite)()) { if ((data[0u] == static_cast(1u)) && (exp == static_cast(0))) { const typename array_type::const_iterator it_non_zero = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate); - return (it_non_zero == data.end()); - } - else if ((data[0u] == static_cast(cpp_dec_float_elem_mask - 1)) && (exp == static_cast(-cpp_dec_float_elem_digits10))) - { - const typename array_type::const_iterator it_non_nine = std::find_if(data.begin(), data.end(), data_elem_is_non_nine_predicate); - return (it_non_nine == data.end()); - } - } - - return false; -} - -template -bool cpp_dec_float::isone_minus() const -{ - // Check if the value of *this is identically 1 or very close to 1. - const bool is_negative_and_is_finite = (neg && (isfinite)()); + const bool result_one_is_ok = (it_non_zero == data.end()); - if (is_negative_and_is_finite) - { - if ((data[0u] == static_cast(1u)) && (exp == static_cast(0))) - { - const typename array_type::const_iterator it_non_zero = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate); - return (it_non_zero == data.end()); + return result_one_is_ok; } else if ((data[0u] == static_cast(cpp_dec_float_elem_mask - 1)) && (exp == static_cast(-cpp_dec_float_elem_digits10))) { const typename array_type::const_iterator it_non_nine = std::find_if(data.begin(), data.end(), data_elem_is_non_nine_predicate); - return (it_non_nine == data.end()); + + const bool result_one_is_ok = (it_non_nine == data.end()); + + return result_one_is_ok; } } From da2f57fc68a8cda19653049d88e27305615c6a68 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 4 Jul 2025 06:30:53 +0200 Subject: [PATCH 004/114] Make better use of compiler switches --- include/boost/multiprecision/detail/default_ops.hpp | 10 ++++------ test/test_various_edges.cpp | 2 ++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index 6e1aeb354..0e8debe1e 100644 --- a/include/boost/multiprecision/detail/default_ops.hpp +++ b/include/boost/multiprecision/detail/default_ops.hpp @@ -1803,9 +1803,7 @@ BOOST_MP_CXX14_CONSTEXPR void eval_karatsuba_sqrt(Backend& result, const Backend result = s; } -// LCOV_EXCL_START -// This is known tested in the test-file test_various_edges.cpp. - +#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION template void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) { @@ -1863,8 +1861,7 @@ void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) --g; } while (g >= 0); } - -// LCOV_EXCL_STOP +#endif // !BOOST_MP_NO_CONSTEXPR_DETECTION template BOOST_MP_CXX14_CONSTEXPR void eval_integer_sqrt(Backend& result, Backend& r, const Backend& x) @@ -1873,7 +1870,8 @@ BOOST_MP_CXX14_CONSTEXPR void eval_integer_sqrt(Backend& result, Backend& r, con // recursive Karatsuba sqrt can cause issues in constexpr context: if (BOOST_MP_IS_CONST_EVALUATED(result.size())) return eval_integer_sqrt_bitwise(result, r, x); -#endif +#endif // !BOOST_MP_NO_CONSTEXPR_DETECTION + using small_uint = typename std::tuple_element<0, typename Backend::unsigned_types>::type; constexpr small_uint zero = 0u; diff --git a/test/test_various_edges.cpp b/test/test_various_edges.cpp index 03363efc7..260b5c624 100644 --- a/test/test_various_edges.cpp +++ b/test/test_various_edges.cpp @@ -1620,6 +1620,7 @@ namespace local auto test_sqrt_integral_and_constexpr() -> void { + #ifndef BOOST_MP_NO_CONSTEXPR_DETECTION { // Select some pseudo-random integers @@ -1676,6 +1677,7 @@ namespace local BOOST_TEST(sqrt(boost::multiprecision::uint128_t("1")) == boost::multiprecision::uint128_t(UINT8_C(1))); BOOST_TEST(sqrt(boost::multiprecision::uint128_t("2")) == boost::multiprecision::uint128_t(UINT8_C(1))); } + #endif // !BOOST_MP_NO_CONSTEXPR_DETECTION } } // namespace local From 590d9565a319e49eb80ef31cc4f64ad63a2c08bd Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 4 Jul 2025 11:36:24 +0200 Subject: [PATCH 005/114] Rework shadow vars and string over/underflow --- .../boost/multiprecision/cpp_dec_float.hpp | 240 +++++++++--------- test/test_various_edges_more.cpp | 100 ++++++++ 2 files changed, 224 insertions(+), 116 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 9d8a30eac..b2604dd45 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -553,11 +553,12 @@ class cpp_dec_float void serialize(Archive& ar, const unsigned int /*version*/) { for (unsigned i = 0; i < data.size(); ++i) - ar& boost::make_nvp("digit", data[i]); - ar& boost::make_nvp("exponent", exp); - ar& boost::make_nvp("sign", neg); - ar& boost::make_nvp("class-type", fpclass); - ar& boost::make_nvp("precision", prec_elem); + ar & boost::make_nvp("digit", data[i]); + + ar & boost::make_nvp("exponent", exp); + ar & boost::make_nvp("sign", neg); + ar & boost::make_nvp("class-type", fpclass); + ar & boost::make_nvp("precision", prec_elem); } #endif @@ -1612,13 +1613,13 @@ double cpp_dec_float::extract_double() const : -std::numeric_limits::infinity()); } - std::stringstream ss; - ss.imbue(std::locale::classic()); + std::stringstream strm; + strm.imbue(std::locale::classic()); - ss << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); + strm << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); double d; - ss >> d; + strm >> d; return d; } @@ -1659,13 +1660,13 @@ long double cpp_dec_float::extract_long_doubl : -std::numeric_limits::infinity()); } - std::stringstream ss; - ss.imbue(std::locale::classic()); + std::stringstream strm; + strm.imbue(std::locale::classic()); - ss << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); + strm << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); long double ld; - ss >> ld; + strm >> ld; return ld; } @@ -1936,9 +1937,9 @@ std::string cpp_dec_float::str(std::intmax_t return "nan"; } - std::string str; + std::string my_str; std::intmax_t org_digits(number_of_digits); - exponent_type my_exp = order(); + exponent_type my_exp = order(); if (!(f & std::ios_base::fixed) && (number_of_digits == 0)) number_of_digits = cpp_dec_float_max_digits10; @@ -1954,17 +1955,17 @@ std::string cpp_dec_float::str(std::intmax_t static_cast(cpp_dec_float_elem_number)); // Extract the remaining digits from cpp_dec_float after the decimal point. - std::stringstream ss; - ss.imbue(std::locale::classic()); - ss << data[0]; + std::stringstream strm; + strm.imbue(std::locale::classic()); + strm << data[0]; // Extract all of the digits from cpp_dec_float, beginning with the first data element. for (std::size_t i = static_cast(1u); i < number_of_elements; i++) { - ss << std::setw(static_cast(cpp_dec_float_elem_digits10)) - << std::setfill(static_cast('0')) - << data[i]; + strm << std::setw(static_cast(cpp_dec_float_elem_digits10)) + << std::setfill(static_cast('0')) + << data[i]; } - str += ss.str(); + my_str += strm.str(); bool have_leading_zeros = false; @@ -1975,37 +1976,37 @@ std::string cpp_dec_float::str(std::intmax_t number_of_digits -= my_exp + 1; // reset to original value if (number_of_digits) { - str.insert(static_cast(0), std::string::size_type(number_of_digits), '0'); + my_str.insert(static_cast(0), std::string::size_type(number_of_digits), '0'); have_leading_zeros = true; } } if (number_of_digits < 0) { - str = "0"; + my_str = "0"; if (isneg()) - str.insert(static_cast(0), 1, '-'); - boost::multiprecision::detail::format_float_string(str, 0, number_of_digits - my_exp - 1, f, this->iszero()); - return str; + my_str.insert(static_cast(0), 1, '-'); + boost::multiprecision::detail::format_float_string(my_str, 0, number_of_digits - my_exp - 1, f, this->iszero()); + return my_str; } else { // Cut the output to the size of the precision. - if (str.length() > static_cast(number_of_digits)) + if (my_str.length() > static_cast(number_of_digits)) { // Get the digit after the last needed digit for rounding - const std::uint32_t round = static_cast(static_cast(str[static_cast(number_of_digits)]) - static_cast('0')); + const std::uint32_t round = static_cast(static_cast(my_str[static_cast(number_of_digits)]) - static_cast('0')); bool need_round_up = round >= 5u; if (round == 5u) { - const std::uint32_t ix = number_of_digits == 0 ? 0 : static_cast(static_cast(str[static_cast(number_of_digits - 1)]) - static_cast('0')); + const std::uint32_t ix = number_of_digits == 0 ? 0 : static_cast(static_cast(my_str[static_cast(number_of_digits - 1)]) - static_cast('0')); if ((ix & 1u) == 0) { // We have an even digit followed by a 5, so we might not actually need to round up // if all the remaining digits are zero: - if (str.find_first_not_of('0', static_cast(number_of_digits + 1)) == std::string::npos) + if (my_str.find_first_not_of('0', static_cast(number_of_digits + 1)) == std::string::npos) { bool all_zeros = true; // No none-zero trailing digits in the string, now check whatever parts we didn't convert to the string: @@ -2024,45 +2025,45 @@ std::string cpp_dec_float::str(std::intmax_t } // Truncate the string - str.erase(static_cast(number_of_digits)); + my_str.erase(static_cast(number_of_digits)); if (need_round_up) { - if (str.size()) + if (my_str.size()) { - std::size_t ix = static_cast(str.length() - 1u); + std::size_t ix = static_cast(my_str.length() - 1u); // Every trailing 9 must be rounded up - while (ix && (static_cast(str.at(ix)) - static_cast('0') == static_cast(9))) + while (ix && (static_cast(my_str.at(ix)) - static_cast('0') == static_cast(9))) { - str.at(ix) = static_cast('0'); + my_str.at(ix) = static_cast('0'); --ix; } if (!ix) { // There were nothing but trailing nines. - if (static_cast(static_cast(str.at(ix)) - static_cast(0x30)) == static_cast(9)) + if (static_cast(static_cast(my_str.at(ix)) - static_cast(0x30)) == static_cast(9)) { // Increment up to the next order and adjust exponent. - str.at(ix) = static_cast('1'); + my_str.at(ix) = static_cast('1'); ++my_exp; } else { // Round up this digit. - ++str.at(ix); + ++my_str.at(ix); } } else { // Round up the last digit. - ++str[ix]; + ++my_str[ix]; } } else { - str = "1"; + my_str = "1"; ++my_exp; } } @@ -2073,20 +2074,20 @@ std::string cpp_dec_float::str(std::intmax_t { // We need to take the zeros back out again, and correct the exponent // if we rounded up: - if (str[std::string::size_type(number_of_digits - 1)] != '0') + if (my_str[std::string::size_type(number_of_digits - 1)] != '0') { ++my_exp; - str.erase(0, std::string::size_type(number_of_digits - 1)); + my_str.erase(0, std::string::size_type(number_of_digits - 1)); } else - str.erase(0, std::string::size_type(number_of_digits)); + my_str.erase(0, std::string::size_type(number_of_digits)); } if (isneg()) - str.insert(static_cast(0), 1, '-'); + my_str.insert(static_cast(0), 1, '-'); - boost::multiprecision::detail::format_float_string(str, my_exp, org_digits, f, this->iszero()); - return str; + boost::multiprecision::detail::format_float_string(my_str, my_exp, org_digits, f, this->iszero()); + return my_str; } template @@ -2097,7 +2098,7 @@ bool cpp_dec_float::rd_string(const char* con { #endif - std::string str(s); + std::string my_str(s); static const std::string valid_characters{"0123456789"}; // TBD: Using several regular expressions may significantly reduce @@ -2108,39 +2109,39 @@ bool cpp_dec_float::rd_string(const char* con std::size_t pos; - if (((pos = str.find('e')) != std::string::npos) || ((pos = str.find('E')) != std::string::npos)) + if (((pos = my_str.find('e')) != std::string::npos) || ((pos = my_str.find('E')) != std::string::npos)) { // Remove the exponent part from the string. #ifndef BOOST_MP_STANDALONE - exp = boost::lexical_cast(static_cast(str.c_str() + (pos + 1u))); + exp = boost::lexical_cast(static_cast(my_str.c_str() + (pos + 1u))); #else - if (str.find_first_not_of(valid_characters, ((str[pos + 1] == '+') || (str[pos + 1] == '-')) ? pos + 2 : pos + 1) != std::string::npos) + if (my_str.find_first_not_of(valid_characters, ((my_str[pos + 1] == '+') || (my_str[pos + 1] == '-')) ? pos + 2 : pos + 1) != std::string::npos) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); - exp = static_cast(std::atoll(static_cast(str.c_str() + (pos + 1u)))); + exp = static_cast(std::atoll(static_cast(my_str.c_str() + (pos + 1u)))); #endif - - str = str.substr(static_cast(0u), pos); + + my_str = my_str.substr(static_cast(0u), pos); } // Get a possible +/- sign and remove it. neg = false; - if (str.size()) + if (my_str.size()) { - if (str[0] == '-') + if (my_str[0] == '-') { neg = true; - str.erase(0, 1); + my_str.erase(0, 1); } - else if (str[0] == '+') + else if (my_str[0] == '+') { - str.erase(0, 1); + my_str.erase(0, 1); } } // // Special cases for infinities and NaN's: // - if ((str == "inf") || (str == "INF") || (str == "infinity") || (str == "INFINITY")) + if ((my_str == "inf") || (my_str == "INF") || (my_str == "infinity") || (my_str == "INFINITY")) { if (neg) { @@ -2151,18 +2152,18 @@ bool cpp_dec_float::rd_string(const char* con *this = this->inf(); return true; } - if ((str.size() >= 3) && ((str.substr(0, 3) == "nan") || (str.substr(0, 3) == "NAN") || (str.substr(0, 3) == "NaN"))) + if ((my_str.size() >= 3) && ((my_str.substr(0, 3) == "nan") || (my_str.substr(0, 3) == "NAN") || (my_str.substr(0, 3) == "NaN"))) { *this = this->nan(); return true; } // Remove the leading zeros for all input types. - const std::string::iterator fwd_it_leading_zero = std::find_if(str.begin(), str.end(), char_is_nonzero_predicate); + const std::string::iterator fwd_it_leading_zero = std::find_if(my_str.begin(), my_str.end(), char_is_nonzero_predicate); - if (fwd_it_leading_zero != str.begin()) + if (fwd_it_leading_zero != my_str.begin()) { - if (fwd_it_leading_zero == str.end()) + if (fwd_it_leading_zero == my_str.end()) { // The string contains nothing but leading zeros. // This string represents zero. @@ -2171,7 +2172,7 @@ bool cpp_dec_float::rd_string(const char* con } else { - str.erase(str.begin(), fwd_it_leading_zero); + my_str.erase(my_str.begin(), fwd_it_leading_zero); } } @@ -2182,32 +2183,33 @@ bool cpp_dec_float::rd_string(const char* con // even multiple of cpp_dec_float_elem_digits10. // Find a possible decimal point. - pos = str.find(static_cast('.')); + pos = my_str.find(static_cast('.')); if (pos != std::string::npos) { // Check we have only digits either side of the point: - if (str.find_first_not_of(valid_characters) != pos) + if (my_str.find_first_not_of(valid_characters) != pos) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); - if (str.find_first_not_of(valid_characters, pos + 1) != std::string::npos) + if (my_str.find_first_not_of(valid_characters, pos + 1) != std::string::npos) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // Remove all trailing insignificant zeros. - const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), char_is_nonzero_predicate); + const std::string::const_reverse_iterator rit_non_zero = std::find_if(my_str.rbegin(), my_str.rend(), char_is_nonzero_predicate); - if (rit_non_zero != static_cast(str.rbegin())) + if (rit_non_zero != static_cast(my_str.rbegin())) { const std::string::size_type ofs = static_cast ( - static_cast(str.length()) - - std::distance(str.rbegin(), rit_non_zero) + static_cast(my_str.length()) + - std::distance(my_str.rbegin(), rit_non_zero) ); - str.erase(str.begin() + static_cast(ofs), str.end()); + + my_str.erase(my_str.begin() + static_cast(ofs), my_str.end()); } // Check if the input is identically zero. - if (str == std::string(".")) + if (my_str == std::string(".")) { operator=(zero()); return true; @@ -2217,31 +2219,31 @@ bool cpp_dec_float::rd_string(const char* con // and adjust the exponent accordingly. // Note that the while-loop operates only on strings of the form ".000abcd..." // and peels away the zeros just after the decimal point. - if (str.at(static_cast(0u)) == static_cast('.')) + if (my_str.at(static_cast(0u)) == static_cast('.')) { - const std::string::iterator it_non_zero = std::find_if(str.begin() + 1u, str.end(), char_is_nonzero_predicate); + const std::string::iterator it_non_zero = std::find_if(my_str.begin() + 1u, my_str.end(), char_is_nonzero_predicate); std::size_t delta_exp = static_cast(0u); - if (str.at(static_cast(1u)) == static_cast('0')) + if (my_str.at(static_cast(1u)) == static_cast('0')) { - delta_exp = static_cast(std::distance(str.begin() + 1u, it_non_zero)); + delta_exp = static_cast(std::distance(my_str.begin() + 1u, it_non_zero)); } // Bring one single digit into the mantissa and adjust the exponent accordingly. - str.erase(str.begin(), it_non_zero); - str.insert(static_cast(1u), "."); + my_str.erase(my_str.begin(), it_non_zero); + my_str.insert(static_cast(1u), "."); exp -= static_cast(delta_exp + 1u); } } else { // We should have only digits: - if (str.find_first_not_of(valid_characters) != std::string::npos) + if (my_str.find_first_not_of(valid_characters) != std::string::npos) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // Input string has no decimal point: Append decimal point. - str.append("."); + my_str.append("."); } // Shift the decimal point such that the exponent is an even multiple of cpp_dec_float_elem_digits10. @@ -2256,29 +2258,29 @@ bool cpp_dec_float::rd_string(const char* con } // Make sure that there are enough digits for the decimal point shift. - pos = str.find(static_cast('.')); + pos = my_str.find(static_cast('.')); std::ptrdiff_t pos_plus_one = static_cast(pos + 1); - if ((static_cast(str.length()) - pos_plus_one) < n_shift) + if ((static_cast(my_str.length()) - pos_plus_one) < n_shift) { - const std::ptrdiff_t sz = static_cast(n_shift - (static_cast(str.length()) - pos_plus_one)); + const std::ptrdiff_t sz = static_cast(n_shift - (static_cast(my_str.length()) - pos_plus_one)); - str.append(std::string(static_cast(sz), static_cast('0'))); + my_str.append(std::string(static_cast(sz), static_cast('0'))); } // Do the decimal point shift. if (n_shift != static_cast(0)) { - str.insert(static_cast(pos_plus_one + n_shift), "."); + my_str.insert(static_cast(pos_plus_one + n_shift), "."); - str.erase(pos, static_cast(1)); + my_str.erase(pos, static_cast(1)); exp -= static_cast(n_shift); } // Cut the size of the mantissa to <= cpp_dec_float_elem_digits10. - pos = str.find(static_cast('.')); + pos = my_str.find(static_cast('.')); pos_plus_one = static_cast(pos + 1u); if (pos > static_cast(cpp_dec_float_elem_digits10)) @@ -2287,25 +2289,25 @@ bool cpp_dec_float::rd_string(const char* con const std::int32_t n_rem_is_zero = ((static_cast(n_pos % cpp_dec_float_elem_digits10) == static_cast(0)) ? static_cast(1) : static_cast(0)); const std::int32_t n = static_cast(static_cast(n_pos / cpp_dec_float_elem_digits10) - n_rem_is_zero); - str.insert(static_cast(static_cast(n_pos - static_cast(n * cpp_dec_float_elem_digits10))), "."); + my_str.insert(static_cast(static_cast(n_pos - static_cast(n * cpp_dec_float_elem_digits10))), "."); - str.erase(static_cast(pos_plus_one), static_cast(1u)); + my_str.erase(static_cast(pos_plus_one), static_cast(1u)); exp += static_cast(static_cast(n) * static_cast(cpp_dec_float_elem_digits10)); } // Pad the decimal part such that its value is an even // multiple of cpp_dec_float_elem_digits10. - pos = str.find(static_cast('.')); + pos = my_str.find(static_cast('.')); pos_plus_one = static_cast(pos + 1u); // Throws an error for a strange construction like 3.14L - if(pos != std::string::npos && (str.back() == 'L' || str.back() == 'l' || str.back() == 'u' || str.back() == 'U')) + if(pos != std::string::npos && (my_str.back() == 'L' || my_str.back() == 'l' || my_str.back() == 'u' || my_str.back() == 'U')) { BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with an integer literal")); } - const std::int32_t n_dec = static_cast(static_cast(str.length() - 1u) - static_cast(pos)); + const std::int32_t n_dec = static_cast(static_cast(my_str.length() - 1u) - static_cast(pos)); const std::int32_t n_rem = static_cast(n_dec % cpp_dec_float_elem_digits10); std::int32_t n_cnt = ((n_rem != static_cast(0)) @@ -2314,16 +2316,16 @@ bool cpp_dec_float::rd_string(const char* con if (n_cnt != static_cast(0)) { - str.append(static_cast(n_cnt), static_cast('0')); + my_str.append(static_cast(n_cnt), static_cast('0')); } // Truncate decimal part if it is too long. const std::size_t max_dec = static_cast((cpp_dec_float_elem_number - 1) * cpp_dec_float_elem_digits10); - if (static_cast(str.length() - pos) > max_dec) + if (static_cast(my_str.length() - pos) > max_dec) { - str = str.substr(static_cast(0u), - static_cast(pos_plus_one + static_cast(max_dec))); + my_str = my_str.substr(static_cast(0u), + static_cast(pos_plus_one + static_cast(max_dec))); } // Now the input string has the standard cpp_dec_float input form. @@ -2335,19 +2337,19 @@ bool cpp_dec_float::rd_string(const char* con // Extract the data. // First get the digits to the left of the decimal point... - data[0u] = static_cast(std::stol(str.substr(static_cast(0u), pos))); + data[0u] = static_cast(std::stol(my_str.substr(static_cast(0u), pos))); // ...then get the remaining digits to the right of the decimal point. const std::string::size_type i_end = ( - static_cast(str.length() - static_cast(pos_plus_one)) + static_cast(my_str.length() - static_cast(pos_plus_one)) / static_cast(cpp_dec_float_elem_digits10) ); for (std::string::size_type i = static_cast(0u); i < i_end; i++) { const std::string::const_iterator it = - str.begin() + my_str.begin() + static_cast ( static_cast(pos_plus_one) @@ -2358,36 +2360,42 @@ bool cpp_dec_float::rd_string(const char* con } // Check for overflow... - if (exp > cpp_dec_float_max_exp10) + if (exp >= cpp_dec_float_max_exp10) { - const bool b_result_is_neg = neg; + const bool neg_tmp { neg }; - *this = inf(); - if (b_result_is_neg) - negate(); + neg = false; + + const int compare_result { compare((cpp_dec_float::max)()) }; + + if(compare_result > 0) + { + *this = inf(); + } + + neg = neg_tmp; } // ...and check for underflow. if (exp <= cpp_dec_float_min_exp10) { - if (exp == cpp_dec_float_min_exp10) - { - // Check for identity with the minimum value. - cpp_dec_float test = *this; + const bool neg_tmp { neg }; - test.exp = static_cast(0); + neg = false; - if (test.isone()) - { - *this = zero(); - } + const int compare_result { compare((cpp_dec_float::min)()) }; + + if(compare_result < 0) + { + *this = zero(); } else { - *this = zero(); + neg = neg_tmp; } } + #ifndef BOOST_NO_EXCEPTIONS } #ifndef BOOST_MP_STANDALONE diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index e2a0191d2..46bd34cf4 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -610,6 +610,105 @@ namespace local return result_of_trip_is_ok; } + + + template + auto test_cpp_dec_float_rd_ovf_unf() -> void + { + using local_cpp_dec_float_type = CppDecFloatType; + + { + typename local_cpp_dec_float_type::backend_type::exponent_type max_exp { }; + + std::string str_max_pos_01("+1.0E+"); + std::string str_max_pos_02("+2.0E+"); + std::string str_max_pos_03("+3.0E+"); + std::string str_max_pos_04("+0.9E+"); + + std::string str_max_neg_01("-1.0E+"); + std::string str_max_neg_02("-2.0E+"); + std::string str_max_neg_03("-3.0E+"); + std::string str_max_neg_04("-0.9E+"); + + { + std::stringstream strm { }; + + strm << std::numeric_limits::max_exponent10; + + str_max_pos_01 += strm.str(); + str_max_pos_02 += strm.str(); + str_max_pos_03 += strm.str(); + str_max_pos_04 += strm.str(); + + str_max_neg_01 += strm.str(); + str_max_neg_02 += strm.str(); + str_max_neg_03 += strm.str(); + str_max_neg_04 += strm.str(); + } + + const local_cpp_dec_float_type max_pos_01(str_max_pos_01); + const local_cpp_dec_float_type max_pos_02(str_max_pos_02); + const local_cpp_dec_float_type max_pos_03(str_max_pos_03); + const local_cpp_dec_float_type max_pos_04(str_max_pos_04); + + const local_cpp_dec_float_type max_neg_01(str_max_neg_01); + const local_cpp_dec_float_type max_neg_02(str_max_neg_02); + const local_cpp_dec_float_type max_neg_03(str_max_neg_03); + const local_cpp_dec_float_type max_neg_04(str_max_neg_04); + + using std::signbit; + + BOOST_TEST(max_pos_01 == (std::numeric_limits::max)()); + BOOST_TEST((boost::multiprecision::isinf)(max_pos_02) && (!signbit(max_pos_02))); + BOOST_TEST((boost::multiprecision::isinf)(max_pos_03) && (!signbit(max_pos_03))); + BOOST_TEST(((boost::multiprecision::fpclassify)(max_pos_04) == FP_NORMAL) && (!signbit(max_pos_04))); + + BOOST_TEST(max_neg_01 == (std::numeric_limits::lowest)()); + BOOST_TEST((boost::multiprecision::isinf)(max_neg_02) && signbit(max_neg_02)); + BOOST_TEST((boost::multiprecision::isinf)(max_neg_03) && signbit(max_neg_03)); + BOOST_TEST(((boost::multiprecision::fpclassify)(max_neg_04) == FP_NORMAL) && signbit(max_neg_04)); + } + + { + std::string str_min_pos_01("+1.0E"); + std::string str_min_pos_02("+1.1E"); + std::string str_min_pos_03("+0.9E"); + + std::string str_min_neg_01("-1.0E"); + std::string str_min_neg_02("-1.1E"); + std::string str_min_neg_03("-0.9E"); + + { + std::stringstream strm { }; + + strm << std::numeric_limits::min_exponent10; + + str_min_pos_01 += strm.str(); + str_min_pos_02 += strm.str(); + str_min_pos_03 += strm.str(); + + str_min_neg_01 += strm.str(); + str_min_neg_02 += strm.str(); + str_min_neg_03 += strm.str(); + } + + const local_cpp_dec_float_type min_pos_01(str_min_pos_01); + const local_cpp_dec_float_type min_pos_02(str_min_pos_02); + const local_cpp_dec_float_type min_pos_03(str_min_pos_03); + + const local_cpp_dec_float_type min_neg_01(str_min_neg_01); + const local_cpp_dec_float_type min_neg_02(str_min_neg_02); + const local_cpp_dec_float_type min_neg_03(str_min_neg_03); + + BOOST_TEST(min_pos_01 == (std::numeric_limits::min)()); + BOOST_TEST(((boost::multiprecision::fpclassify)(min_pos_02) == FP_NORMAL) && (!signbit(min_pos_02))); + BOOST_TEST(((boost::multiprecision::fpclassify)(min_pos_03) == FP_ZERO) && (!signbit(min_pos_03))); + + BOOST_TEST(min_neg_01 == -(std::numeric_limits::min)()); + BOOST_TEST(((boost::multiprecision::fpclassify)(min_neg_02) == FP_NORMAL) && signbit(min_neg_02)); + BOOST_TEST(((boost::multiprecision::fpclassify)(min_neg_03) == FP_ZERO) && (!signbit(min_neg_03))); + } + } } // namespace local auto main() -> int @@ -632,6 +731,7 @@ auto main() -> int std::cout << "Testing type: " << typeid(float_type).name() << std::endl; static_cast(local::test_edges()); + local::test_cpp_dec_float_rd_ovf_unf(); } { From 64c8c8d40b8fdd06707755cd29dbb844275b0891 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 4 Jul 2025 14:57:53 +0200 Subject: [PATCH 006/114] Try for more coverage --- .../boost/multiprecision/complex_adaptor.hpp | 73 ++++----- .../boost/multiprecision/cpp_dec_float.hpp | 139 ++++++++++-------- test/test_complex.cpp | 126 +++++++++++++++- test/test_various_edges_more.cpp | 7 +- 4 files changed, 240 insertions(+), 105 deletions(-) diff --git a/include/boost/multiprecision/complex_adaptor.hpp b/include/boost/multiprecision/complex_adaptor.hpp index d5edd917f..40ec4d74d 100644 --- a/include/boost/multiprecision/complex_adaptor.hpp +++ b/include/boost/multiprecision/complex_adaptor.hpp @@ -1,5 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright 2018 John Maddock. Distributed under the Boost +// Copyright 2018 - 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. +// 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) @@ -7,13 +9,14 @@ #define BOOST_MP_COMPLEX_ADAPTOR_HPP #include -#include #include #include #include -#include + #include +#include #include +#include namespace boost { namespace multiprecision { @@ -479,37 +482,37 @@ inline void eval_sqrt(complex_adaptor& result, const complex_adaptor& result, const complex_adaptor __my_z_times_i, t1, t2, t3; - assign_components(__my_z_times_i, arg.imag_data(), arg.real_data()); - __my_z_times_i.real_data().negate(); + complex_adaptor my_z_times_i, t1, t2, t3; + assign_components(my_z_times_i, arg.imag_data(), arg.real_data()); + my_z_times_i.real_data().negate(); - eval_add(t1, __my_z_times_i, one); + eval_add(t1, my_z_times_i, one); eval_log(t2, t1); - eval_subtract(t1, one, __my_z_times_i); + eval_subtract(t1, one, my_z_times_i); eval_log(t3, t1); eval_subtract(t1, t3, t2); @@ -881,15 +884,15 @@ inline void eval_acosh(complex_adaptor& result, const complex_adaptor __my_zp(arg); - eval_add(__my_zp.real_data(), one); - complex_adaptor __my_zm(arg); - eval_subtract(__my_zm.real_data(), one); + complex_adaptor my_zp(arg); + eval_add(my_zp.real_data(), one); + complex_adaptor my_zm(arg); + eval_subtract(my_zm.real_data(), one); complex_adaptor t1, t2; - eval_divide(t1, __my_zm, __my_zp); + eval_divide(t1, my_zm, my_zp); eval_sqrt(t2, t1); - eval_multiply(t2, __my_zp); + eval_multiply(t2, my_zp); eval_add(t2, arg); eval_log(result, t2); } diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index b2604dd45..dade69830 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -505,23 +505,53 @@ class cpp_dec_float exponent_type order() const { const bool bo_order_is_zero = ((!(isfinite)()) || (data[0] == static_cast(0u))); + + exponent_type prefix = limb_order(data[static_cast(UINT8_C(0))]); + + return (bo_order_is_zero ? static_cast(0) : static_cast(exp + prefix)); + } + + #ifndef BOOST_MP_STANDALONE + template + void serialize(Archive& ar, const unsigned int /*version*/) + { + for (unsigned i = 0; i < data.size(); ++i) + ar & boost::make_nvp("digit", data[i]); + + ar & boost::make_nvp("exponent", exp); + ar & boost::make_nvp("sign", neg); + ar & boost::make_nvp("class-type", fpclass); + ar & boost::make_nvp("precision", prec_elem); + } + #endif + + private: + static bool data_elem_is_non_zero_predicate(const std::uint32_t& d) { return (d != static_cast(0u)); } + static bool data_elem_is_non_nine_predicate(const std::uint32_t& d) { return (d != static_cast(cpp_dec_float::cpp_dec_float_elem_mask - 1)); } + static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast('0')); } + + // Inversion. + cpp_dec_float& calculate_inv(); + + static exponent_type limb_order(const limb_type limb) + { // // Binary search to find the order of the leading term: // exponent_type prefix = 0; - if (data[0] >= 100000UL) + if (limb >= 100000UL) { - if (data[0] >= 10000000UL) + if (limb >= 10000000UL) { - if (data[0] >= 100000000UL) + if (limb >= 100000000UL) prefix = 8; else prefix = 7; } else { - if (data[0] >= 1000000UL) + if (limb >= 1000000UL) prefix = 6; else prefix = 5; @@ -529,46 +559,24 @@ class cpp_dec_float } else { - if (data[0] >= 1000UL) + if (limb >= 1000UL) { - if (data[0] >= 10000UL) + if (limb >= 10000UL) prefix = 4; else prefix = 3; } else { - if (data[0] >= 100) + if (limb >= 100) prefix = 2; - else if (data[0] >= 10) + else if (limb >= 10) prefix = 1; } } - return (bo_order_is_zero ? static_cast(0) : static_cast(exp + prefix)); - } - - #ifndef BOOST_MP_STANDALONE - template - void serialize(Archive& ar, const unsigned int /*version*/) - { - for (unsigned i = 0; i < data.size(); ++i) - ar & boost::make_nvp("digit", data[i]); - - ar & boost::make_nvp("exponent", exp); - ar & boost::make_nvp("sign", neg); - ar & boost::make_nvp("class-type", fpclass); - ar & boost::make_nvp("precision", prec_elem); + return prefix; } - #endif - - private: - static bool data_elem_is_non_zero_predicate(const std::uint32_t& d) { return (d != static_cast(0u)); } - static bool data_elem_is_non_nine_predicate(const std::uint32_t& d) { return (d != static_cast(cpp_dec_float::cpp_dec_float_elem_mask - 1)); } - static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast('0')); } - - // Inversion. - cpp_dec_float& calculate_inv(); bool isone() const { @@ -1531,49 +1539,52 @@ bool cpp_dec_float::isint() const template void cpp_dec_float::extract_parts(double& mantissa, ExponentType& exponent) const { - // Extract the approximate parts mantissa and base-10 exponent from the input cpp_dec_float value x. + // Extract the approximate parts mantissa and base-10 exponent from + // the input cpp_dec_float value x. + // This subroutine is designed to be fast and does not round. - // Extracts the mantissa and exponent. - exponent = exp; + // Extract the mantissa and exponent. - std::uint32_t p10 = static_cast(1u); - std::uint32_t test = data[0u]; + using local_exponent_type = ExponentType; - for (;;) - { - test /= static_cast(10u); + std::size_t index { static_cast(UINT8_C(0)) }; - if (test == static_cast(0u)) - { - break; - } + const local_exponent_type my_order_limb0 { limb_order(data[index]) }; - p10 *= static_cast(10u); - ++exponent; - } + exponent = static_cast(exp + my_order_limb0); - // Establish the upper bound of limbs for extracting the double. - const int max_elem_in_double_count = static_cast(static_cast(std::numeric_limits::digits10) / cpp_dec_float_elem_digits10) + (static_cast(static_cast(std::numeric_limits::digits10) % cpp_dec_float_elem_digits10) != 0 ? 1 : 0) + 1; + // Extract into the mantissa the first limb, extracted as a double. - // And make sure this upper bound stays within bounds of the elems. - const std::size_t max_elem_extract_count = static_cast((std::min)(static_cast(max_elem_in_double_count), cpp_dec_float_elem_number)); + mantissa = ((!neg) ? static_cast(data[index]) : -static_cast(data[index])); - // Extract into the mantissa the first limb, extracted as a double. - mantissa = static_cast(data[0]); - double scale = 1.0; + ++index; - // Extract the rest of the mantissa piecewise from the limbs. - for (std::size_t i = 1u; i < max_elem_extract_count; i++) + int digit_counter { }; + + double p10 { 1.0 }; + + // Scale the first limb with its order. + for ( ; digit_counter < static_cast(my_order_limb0); ++digit_counter) { - scale /= static_cast(cpp_dec_float_elem_mask); - mantissa += (static_cast(data[i]) * scale); + mantissa /= 10.0; + + p10 *= 10.0; } - mantissa /= static_cast(p10); + // Extract the rest of the mantissa piecewise from the limbs. + // Keep a running power-of-ten scale in the variable p10. + // This loop does not round. - if (neg) + while ( (digit_counter < std::numeric_limits::max_digits10 + 2) + && (index < static_cast(cpp_dec_float_elem_number))) { - mantissa = -mantissa; + p10 *= static_cast(cpp_dec_float_elem_mask); + + mantissa += static_cast(static_cast(data[index]) / p10); + + ++index; + + digit_counter += static_cast(cpp_dec_float_elem_digits10); } } @@ -1591,12 +1602,13 @@ double cpp_dec_float::extract_double() const } else { - return ((!neg) ? std::numeric_limits::infinity() + return ((!neg) ? +std::numeric_limits::infinity() : -std::numeric_limits::infinity()); } } cpp_dec_float xx(*this); + if (xx.isneg()) xx.negate(); @@ -1609,11 +1621,12 @@ double cpp_dec_float::extract_double() const // Check if *this cpp_dec_float exceeds the maximum of double. if (xx.compare(double_max()) > 0) { - return ((!neg) ? std::numeric_limits::infinity() + return ((!neg) ? +std::numeric_limits::infinity() : -std::numeric_limits::infinity()); } - std::stringstream strm; + std::stringstream strm { }; + strm.imbue(std::locale::classic()); strm << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); diff --git a/test/test_complex.cpp b/test/test_complex.cpp index 86b7cfaa4..b89ab45bb 100644 --- a/test/test_complex.cpp +++ b/test/test_complex.cpp @@ -9,34 +9,72 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 +#include + #include +#include +#include + #ifdef TEST_MPC #include #endif -#include -#include #ifdef BOOST_HAS_FLOAT128 #include #endif +#if 0 // Testing cpp_dec_float does not (yet) work. +#ifdef TEST_CPP_DEC_FLOAT +#include +#endif +#endif // Testing cpp_dec_float does not (yet) work. #ifdef TEST_CPP_DOUBLE_FLOAT #include #endif -#include #include // Note: include this AFTER the test-backends are defined +#include #include #include #include #include +#include #include +template auto my_zero() noexcept -> FloatType&; + namespace local { + +template +auto time_point() noexcept -> IntegralTimePointType +{ + using local_integral_time_point_type = IntegralTimePointType; + using local_clock_type = ClockType; + + typename local_clock_type::time_point tp_zero { }; + + const auto my_now = local_clock_type::now(); + + const auto duration { my_now - tp_zero }; + + const std::uintmax_t + value + { + static_cast + ( + std::chrono::duration_cast(my_now - tp_zero).count() + ) + }; + + return static_cast(value); +} + template void test() { + std::cout << "Testing type: " << typeid(complex_type).name() << std::endl; - typedef typename complex_type::value_type float_type; + using float_type = typename complex_type::value_type; const std::string str_tol("0." + std::string(std::size_t(std::numeric_limits::digits10 - 2), char('0')) + std::string(std::size_t(2U), char('9'))); @@ -158,6 +196,72 @@ void test() BOOST_CHECK_CLOSE_FRACTION(result_26.imag(), control_26.imag(), tol); BOOST_CHECK_CLOSE_FRACTION(abs(z1), boost::lexical_cast("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), tol) + + { + std::mt19937_64 gen { time_point() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.1F), + static_cast(1.5E10F) + }; + + float_type around_three_base("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"); + + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + const float_type real_val = around_three_base * dis(gen); + + const complex_type cpx(real_val); + + { + const complex_type sqrt_cpx = sqrt(cpx); + const float_type sqrt_ctrl = sqrt(real_val); + + BOOST_CHECK_CLOSE_FRACTION(sqrt_cpx.real(), sqrt_ctrl, tol); + BOOST_TEST((boost::multiprecision::fpclassify)(sqrt_cpx.imag()) == FP_ZERO); + } + + { + const complex_type exp_cpx = exp(cpx); + const float_type exp_ctrl = exp(real_val); + + BOOST_CHECK_CLOSE_FRACTION(exp_cpx.real(), exp_ctrl, tol); + BOOST_TEST((boost::multiprecision::fpclassify)(exp_cpx.imag()) == FP_ZERO); + } + } + + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + const complex_type cpx(around_three_base * dis(gen), around_three_base * dis(gen)); + + const complex_type cpx_zero(::my_zero() * dis(gen), ::my_zero() * dis(gen)); + const complex_type cpx_result = pow(cpx, cpx_zero); + + const bool result_pow_zero_is_ok + { + (cpx_result.real() == 1) + && ((boost::multiprecision::fpclassify)(cpx_result.imag()) == FP_ZERO) + }; + + BOOST_TEST(result_pow_zero_is_ok); + + const complex_type cpx_asin_zero = asin(cpx_zero); + + const bool result_asin_zero_is_ok + { + ((boost::multiprecision::fpclassify)(cpx_asin_zero.real()) == FP_ZERO) + && ((boost::multiprecision::fpclassify)(cpx_asin_zero.imag()) == FP_ZERO) + }; + + BOOST_TEST(result_asin_zero_is_ok); + } + } } } // namespace local @@ -173,6 +277,18 @@ int main() local::test(); #endif +#if 0 // Testing cpp_dec_float does not (yet) work. +#ifdef TEST_CPP_DEC_FLOAT + { + using dec_float_backend_type = boost::multiprecision::cpp_dec_float<50>; + + using dec_float_type = boost::multiprecision::number; + + local::test(); + } +#endif +#endif // Testing cpp_dec_float does not (yet) work. + #if defined(TEST_CPP_DOUBLE_FLOAT) { local::test>, boost::multiprecision::et_off>>(); @@ -185,3 +301,5 @@ int main() return boost::report_errors(); } + +template auto my_zero() noexcept -> FloatType& { using float_type = FloatType; static float_type val_zero { 0 }; return val_zero; } diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 46bd34cf4..98ca76661 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -126,9 +126,9 @@ namespace local for(std::size_t index { std::size_t { UINT8_C(0) }}; index < std::tuple_size::value; ++index) { - const any_float_type start(any_float_type(float_number_strings[index]) * (dis(gen)* dis(gen))); - const other_float_type other(start); - const any_float_type backto(other); + const any_float_type start(boost::lexical_cast(float_number_strings[index]) * (dis(gen)* dis(gen))); + const other_float_type other(static_cast(start)); + const any_float_type backto(static_cast(other)); const bool result_of_trip_is_ok @@ -732,6 +732,7 @@ auto main() -> int static_cast(local::test_edges()); local::test_cpp_dec_float_rd_ovf_unf(); + local::test_convert_and_back(0.0F); } { From be9c643032474f9dab60026e54fa604abf8840ae Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 4 Jul 2025 19:58:46 +0200 Subject: [PATCH 007/114] Try for even more cover lines --- .../boost/multiprecision/cpp_dec_float.hpp | 29 ++++++++++------- test/test_arithmetic.hpp | 16 +++++----- test/test_cpp_bin_float_io.cpp | 6 ++++ test/test_various_edges_more.cpp | 32 +++++++++++++++++++ 4 files changed, 63 insertions(+), 20 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index dade69830..7014e12b5 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -2017,12 +2017,14 @@ std::string cpp_dec_float::str(std::intmax_t const std::uint32_t ix = number_of_digits == 0 ? 0 : static_cast(static_cast(my_str[static_cast(number_of_digits - 1)]) - static_cast('0')); if ((ix & 1u) == 0) { - // We have an even digit followed by a 5, so we might not actually need to round up - // if all the remaining digits are zero: + // We have an even digit followed by a 5, so we might not actually + // need to round up if all the remaining digits are zero: if (my_str.find_first_not_of('0', static_cast(number_of_digits + 1)) == std::string::npos) { bool all_zeros = true; - // No none-zero trailing digits in the string, now check whatever parts we didn't convert to the string: + + // There are no non-zero trailing digits in the string, + // now check whatever parts we didn't convert to the string: for (std::size_t i = number_of_elements; i < data.size(); i++) { if (data[i]) @@ -2139,11 +2141,12 @@ bool cpp_dec_float::rd_string(const char* con // Get a possible +/- sign and remove it. neg = false; - if (my_str.size()) + if (!my_str.empty()) { if (my_str[0] == '-') { neg = true; + my_str.erase(0, 1); } else if (my_str[0] == '+') @@ -2151,23 +2154,25 @@ bool cpp_dec_float::rd_string(const char* con my_str.erase(0, 1); } } + // // Special cases for infinities and NaN's: // if ((my_str == "inf") || (my_str == "INF") || (my_str == "infinity") || (my_str == "INFINITY")) { - if (neg) - { - *this = this->inf(); - this->negate(); - } - else - *this = this->inf(); + const bool tmp_neg { neg }; + + *this = this->inf(); + + neg = tmp_neg; + return true; } + if ((my_str.size() >= 3) && ((my_str.substr(0, 3) == "nan") || (my_str.substr(0, 3) == "NAN") || (my_str.substr(0, 3) == "NaN"))) { *this = this->nan(); + return true; } @@ -2485,7 +2490,7 @@ cpp_dec_float::cpp_dec_float(const double man d -= static_cast(n); d *= static_cast(cpp_dec_float_elem_mask); } -} +} // LCOV_EXCL_LINE template template diff --git a/test/test_arithmetic.hpp b/test/test_arithmetic.hpp index ffde719c4..7d7cd1b7e 100644 --- a/test/test_arithmetic.hpp +++ b/test/test_arithmetic.hpp @@ -3045,45 +3045,45 @@ void test_basic_conditionals(Real a, Real b) { if (a) { - BOOST_ERROR("Unexpected non-zero result"); + BOOST_ERROR("Unexpected non-zero result"); // LCOV_EXCL_LINE } if (!a) { } else { - BOOST_ERROR("Unexpected zero result"); + BOOST_ERROR("Unexpected zero result"); // LCOV_EXCL_LINE } b = 2; if (!b) { - BOOST_ERROR("Unexpected zero result"); + BOOST_ERROR("Unexpected zero result"); // LCOV_EXCL_LINE } if (b) { } else { - BOOST_ERROR("Unexpected non-zero result"); + BOOST_ERROR("Unexpected non-zero result"); // LCOV_EXCL_LINE } if (a && b) { - BOOST_ERROR("Unexpected zero result"); + BOOST_ERROR("Unexpected zero result"); // LCOV_EXCL_LINE } if (!(a || b)) { - BOOST_ERROR("Unexpected zero result"); + BOOST_ERROR("Unexpected zero result"); // LCOV_EXCL_LINE } if (a + b) { } else { - BOOST_ERROR("Unexpected zero result"); + BOOST_ERROR("Unexpected zero result"); // LCOV_EXCL_LINE } if (b - 2) { - BOOST_ERROR("Unexpected non-zero result"); + BOOST_ERROR("Unexpected non-zero result"); // LCOV_EXCL_LINE } } diff --git a/test/test_cpp_bin_float_io.cpp b/test/test_cpp_bin_float_io.cpp index ee22bd151..378eb29e6 100644 --- a/test/test_cpp_bin_float_io.cpp +++ b/test/test_cpp_bin_float_io.cpp @@ -44,6 +44,7 @@ struct stopwatch typename Clock::time_point m_start; }; +// LCOV_EXCL_START void print_flags(std::ios_base::fmtflags f) { std::cout << "Formatting flags were: "; @@ -57,6 +58,7 @@ void print_flags(std::ios_base::fmtflags f) std::cout << "showpos "; std::cout << std::endl; } +// LCOV_EXCL_STOP template void test() @@ -88,6 +90,7 @@ void test() const char* expect = string_data[j][col]; if (ss.str() != expect) { + // LCOV_EXCL_START std::cout << std::setprecision(20) << "Testing value " << val << std::endl; print_flags(f[i]); std::cout << "Precision is: " << prec << std::endl; @@ -95,6 +98,7 @@ void test() std::cout << "Expected: " << expect << std::endl; ++boost::detail::test_errors(); mp_t(val).str(prec, f[i]); // for debugging + // LCOV_EXCL_STOP } } } @@ -120,6 +124,7 @@ void test() const char* expect = zeros[col]; if (ss.str() != expect) { + // LCOV_EXCL_START std::cout << std::setprecision(20) << "Testing value " << val << std::endl; print_flags(f[i]); std::cout << "Precision is: " << prec << std::endl; @@ -127,6 +132,7 @@ void test() std::cout << "Expected: " << expect << std::endl; ++boost::detail::test_errors(); mp_t(val).str(prec, f[i]); // for debugging + // LCOV_EXCL_STOP } } } diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 98ca76661..c1950f1a4 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -358,6 +358,38 @@ namespace local result_is_ok = (result_funky_strings_is_ok && result_is_ok); } + { + const std::initializer_list + infty_strings_list + { + std::string("inf"), std::string("INF"), std::string("infinity"), std::string("INFINITY"), + std::string("+inf"), std::string("+INF"), std::string("+infinity"), std::string("+INFINITY"), + std::string("-inf"), std::string("-INF"), std::string("-infinity"), std::string("-INFINITY") + }; + + const std::vector infty_strings(infty_strings_list); + + std::size_t infty_count { }; + + for(const auto& str : infty_strings) + { + const float_type flt_from_inf_string(str); + + const bool + result_infty_strings_is_ok + { + (boost::multiprecision::isinf)(flt_from_inf_string) + && ((infty_count < std::size_t { UINT8_C(8) }) ? (!signbit(flt_from_inf_string)) : signbit(flt_from_inf_string)) + }; + + ++infty_count; + + BOOST_TEST(result_infty_strings_is_ok); + + result_is_ok = (result_infty_strings_is_ok && result_is_ok); + } + } + { for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) { From af8f932b694f721880c73f174a881ca6775c8fc3 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 4 Jul 2025 20:01:28 +0200 Subject: [PATCH 008/114] Remove an unwanted compiler warning --- test/test_various_edges_more.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index c1950f1a4..dde4531c7 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -650,8 +650,6 @@ namespace local using local_cpp_dec_float_type = CppDecFloatType; { - typename local_cpp_dec_float_type::backend_type::exponent_type max_exp { }; - std::string str_max_pos_01("+1.0E+"); std::string str_max_pos_02("+2.0E+"); std::string str_max_pos_03("+3.0E+"); From 7012b7dd02cdb3dbe34fe7394a8434f89576644e Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 5 Jul 2025 10:53:46 +0200 Subject: [PATCH 009/114] Improve cpp_dec_float and test_exp --- .../boost/multiprecision/cpp_dec_float.hpp | 145 ++++++------------ test/test_exp.cpp | 18 ++- 2 files changed, 60 insertions(+), 103 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 7014e12b5..72375a76d 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1,6 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // Copyright Christopher Kormanyos 2002 - 2025. -// Copyright 2011 -2025 John Maddock. Distributed under the Boost +// Copyright John Maddock 2011 -2025. +// 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) // @@ -8,27 +9,10 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 // -// There are some "noexcept" specifications on the functions in this file. -// Unlike in pre-C++11 versions, compilers can now detect noexcept misuse -// at compile time, allowing for simple use of it here. -// #ifndef BOOST_MP_CPP_DEC_FLOAT_HPP #define BOOST_MP_CPP_DEC_FLOAT_HPP -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include #include #include @@ -57,6 +41,20 @@ #include #endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 6326) // comparison of two constants @@ -135,18 +133,14 @@ class cpp_dec_float cpp_dec_float_NaN } fpclass_type; - array_type data; - exponent_type exp; - bool neg; - fpclass_type fpclass; - std::int32_t prec_elem; + array_type data { }; + exponent_type exp { }; + bool neg { }; + fpclass_type fpclass { cpp_dec_float_finite }; + std::int32_t prec_elem { cpp_dec_float_elem_number }; // Private constructor from the floating-point class type. - explicit cpp_dec_float(fpclass_type c) : data(), - exp(static_cast(0)), - neg(false), - fpclass(c), - prec_elem(cpp_dec_float_elem_number) {} + explicit cpp_dec_float(fpclass_type c) : fpclass(c) { } // Constructor from an initializer_list, an optional // (value-aligned) exponent and a Boolean sign. @@ -167,29 +161,16 @@ class cpp_dec_float public: // Public Constructors - cpp_dec_float() noexcept(noexcept(array_type())) : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) {} - - cpp_dec_float(const char* s) : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) + cpp_dec_float() noexcept(noexcept(array_type())) { } + + cpp_dec_float(const char* s) { *this = s; } template - cpp_dec_float(I i, - typename std::enable_if::value && (sizeof(I) <= sizeof(long long))>::type* = nullptr) - : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) + cpp_dec_float(I i, typename std::enable_if<( boost::multiprecision::detail::is_unsigned::value + && (sizeof(I) <= sizeof(long long)))>::type* = nullptr) { from_unsigned_long_long(i); } @@ -199,11 +180,6 @@ class cpp_dec_float typename std::enable_if<( boost::multiprecision::detail::is_signed::value && boost::multiprecision::detail::is_integral::value && (sizeof(I) <= sizeof(long long)))>::type* = nullptr) - : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) { if (i < 0) { @@ -218,38 +194,30 @@ class cpp_dec_float : data(f.data), exp(f.exp), neg(f.neg), - fpclass(f.fpclass), + fpclass(static_cast(static_cast(f.fpclass))), prec_elem(f.prec_elem) {} template cpp_dec_float(const cpp_dec_float& f, typename std::enable_if::type* = nullptr) - : data(), - exp(f.exp), + : exp(f.exp), neg(f.neg), - fpclass(static_cast(static_cast(f.fpclass))), - prec_elem(cpp_dec_float_elem_number) + fpclass(static_cast(static_cast(f.fpclass))) { std::copy(f.data.begin(), f.data.begin() + f.prec_elem, data.begin()); } + template explicit cpp_dec_float(const cpp_dec_float& f, typename std::enable_if< !(D <= Digits10)>::type* = nullptr) - : data(), - exp(f.exp), + : exp(f.exp), neg(f.neg), - fpclass(static_cast(static_cast(f.fpclass))), - prec_elem(cpp_dec_float_elem_number) + fpclass(static_cast(static_cast(f.fpclass))) { // TODO: this doesn't round! std::copy(f.data.begin(), f.data.begin() + prec_elem, data.begin()); } template - cpp_dec_float(const F val, typename std::enable_if::value - >::type* = nullptr) : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) + cpp_dec_float(const F val, typename std::enable_if::value>::type* = nullptr) { *this = val; } @@ -1547,42 +1515,32 @@ void cpp_dec_float::extract_parts(double& man using local_exponent_type = ExponentType; - std::size_t index { static_cast(UINT8_C(0)) }; - - const local_exponent_type my_order_limb0 { limb_order(data[index]) }; + const local_exponent_type my_order_limb0 { limb_order(data.front()) }; exponent = static_cast(exp + my_order_limb0); // Extract into the mantissa the first limb, extracted as a double. - mantissa = ((!neg) ? static_cast(data[index]) : -static_cast(data[index])); - - ++index; + mantissa = ((!neg) ? static_cast(data.front()) : -static_cast(data.front())); - int digit_counter { }; + int digit_counter { static_cast(my_order_limb0) }; - double p10 { 1.0 }; + // Keep a running power-of-ten scale in the variable p10. + double p10 { static_cast(detail::pow10_maker(static_cast(my_order_limb0))) }; // Scale the first limb with its order. - for ( ; digit_counter < static_cast(my_order_limb0); ++digit_counter) - { - mantissa /= 10.0; - - p10 *= 10.0; - } + mantissa /= p10; // Extract the rest of the mantissa piecewise from the limbs. - // Keep a running power-of-ten scale in the variable p10. // This loop does not round. - while ( (digit_counter < std::numeric_limits::max_digits10 + 2) - && (index < static_cast(cpp_dec_float_elem_number))) + auto itr_data = data.cbegin() + static_cast(UINT8_C(1)); + + while ((itr_data != data.cend()) && (digit_counter <= std::numeric_limits::max_digits10)) { p10 *= static_cast(cpp_dec_float_elem_mask); - mantissa += static_cast(static_cast(data[index]) / p10); - - ++index; + mantissa += static_cast(static_cast(*itr_data++) / p10); digit_counter += static_cast(cpp_dec_float_elem_digits10); } @@ -1629,7 +1587,7 @@ double cpp_dec_float::extract_double() const strm.imbue(std::locale::classic()); - strm << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); + strm << str(std::numeric_limits::max_digits10, std::ios_base::scientific); double d; strm >> d; @@ -1676,7 +1634,7 @@ long double cpp_dec_float::extract_long_doubl std::stringstream strm; strm.imbue(std::locale::classic()); - strm << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); + strm << str(std::numeric_limits::max_digits10, std::ios_base::scientific); long double ld; strm >> ld; @@ -2434,11 +2392,6 @@ bool cpp_dec_float::rd_string(const char* con template cpp_dec_float::cpp_dec_float(const double mantissa, const ExponentType exponent) - : data(), - exp(static_cast(0)), - neg(false), - fpclass(cpp_dec_float_finite), - prec_elem(cpp_dec_float_elem_number) { // Create *this cpp_dec_float from a given mantissa and exponent. // Note: This constructor does not maintain the full precision of double. @@ -2496,9 +2449,11 @@ template template typename std::enable_if::value, cpp_dec_float&>::type cpp_dec_float::operator=(Float a) { - // Christopher Kormanyos's original code used a cast to long long here, but that fails - // when long double has more digits than a long long. + // Christopher Kormanyos's original code used a cast to long long here, + // but that fails when long double has more digits than a long long. + BOOST_MP_FLOAT128_USING + using std::floor; using std::frexp; using std::ldexp; diff --git a/test/test_exp.cpp b/test/test_exp.cpp index 6cc7f1d16..92eaf7419 100644 --- a/test/test_exp.cpp +++ b/test/test_exp.cpp @@ -75,7 +75,7 @@ void test() unsigned max_err = 0; - BOOST_IF_CONSTEXPR (!::has_poor_exp_range_or_precision_support::value) + BOOST_IF_CONSTEXPR (std::numeric_limits::is_specialized && (std::numeric_limits::max_exponent10 > 4000)) { static const std::array data = {{ @@ -159,7 +159,7 @@ void test() #else BOOST_TEST(max_err < 5000); #endif - } // !::has_poor_exp_range_or_precision_support::value + } // (std::numeric_limits::max_exponent10 > 4000) using std::ldexp; @@ -205,8 +205,11 @@ void test() if (!boost::multiprecision::is_interval_number::value) { T bug_case = -1.05 * log((std::numeric_limits::max)()); - for (unsigned i = 0; bug_case > -20 / std::numeric_limits::epsilon(); ++i, bug_case *= 1.05) + + for (unsigned i = 0U; bug_case > -20 / std::numeric_limits::epsilon(); ++i, bug_case *= 1.05) { + static_cast(i); + if (std::numeric_limits::has_infinity) { BOOST_CHECK_EQUAL(exp(bug_case), 0); @@ -217,20 +220,19 @@ void test() } } - // Handle uneven/asymmetric exponents on min/max of cpp_double_fp_backend BOOST_IF_CONSTEXPR (::has_poor_exp_range_or_precision_support::value) { - bug_case = log(1 / (std::numeric_limits::min)()) / -1.0005; + bug_case = log(T(1) / (std::numeric_limits::min)()) / -1.0005; } else { bug_case = log((std::numeric_limits::max)()) / -1.0005; } - unsigned i { 0U }; - - for ( ; i < 20U; ++i, bug_case /= static_cast(1.05L)) + for (unsigned i { 0U }; i < 20U; ++i, bug_case /= static_cast(1.05L)) { + static_cast(i); + BOOST_CHECK_GE(exp(bug_case), (std::numeric_limits::min)()); } } From 0d255d014a0268cd8097d6f8766a5fb2bae9bb80 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 5 Jul 2025 14:05:19 +0200 Subject: [PATCH 010/114] Add more dec_float frexp tests --- .../boost/multiprecision/cpp_dec_float.hpp | 78 +++++++++++++------ test/test_various_edges_more.cpp | 50 +++++++++++- 2 files changed, 103 insertions(+), 25 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 72375a76d..8583bea92 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -3400,34 +3400,50 @@ inline void eval_ldexp(cpp_dec_float& result, { const long long the_exp = static_cast(e); - if ((the_exp > (std::numeric_limits::exponent_type>::max)()) || (the_exp < (std::numeric_limits::exponent_type>::min)())) + using local_cpp_dec_float_type = cpp_dec_float; + using local_exponent_type = typename local_cpp_dec_float_type::exponent_type; + + using local_common_type = typename std::common_type::type; + + if ( (static_cast(the_exp) > static_cast((std::numeric_limits::max)())) + || (static_cast(the_exp) < static_cast((std::numeric_limits::min)()))) + { BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Exponent value is out of range."))); + } result = x; - if ((the_exp > static_cast(-std::numeric_limits::digits)) && (the_exp < static_cast(0))) + if ( (static_cast(the_exp) > static_cast(-std::numeric_limits::digits)) + && (static_cast(the_exp) < static_cast(0))) + { result.div_unsigned_long_long(1ULL << static_cast(-the_exp)); - else if ((the_exp < static_cast(std::numeric_limits::digits)) && (the_exp > static_cast(0))) + } + else if ( (static_cast(the_exp) < static_cast(std::numeric_limits::digits)) + && (static_cast(the_exp) > static_cast(0))) + { result.mul_unsigned_long_long(1ULL << the_exp); + } else if (the_exp != static_cast(0)) { - if ((the_exp < cpp_dec_float::cpp_dec_float_min_exp / 2) && (x.order() > 0)) + if ((the_exp < local_cpp_dec_float_type::cpp_dec_float_min_exp / 2) && (x.order() > 0)) { long long half_exp = e / 2; - cpp_dec_float t = cpp_dec_float::pow2(half_exp); + local_cpp_dec_float_type t { local_cpp_dec_float_type::pow2(half_exp) }; result *= t; if (2 * half_exp != e) t *= 2; result *= t; - } + } // LCOV_EXCL_LINE else - result *= cpp_dec_float::pow2(e); + result *= local_cpp_dec_float_type::pow2(e); } } template inline void eval_frexp(cpp_dec_float& result, const cpp_dec_float& x, ExponentType* e) { + const bool b_neg { x.isneg() }; + result = x; if (result.iszero() || (result.isinf)() || (result.isnan)()) @@ -3436,12 +3452,16 @@ inline void eval_frexp(cpp_dec_float& result, return; } - if (result.isneg()) + if (b_neg) result.negate(); - typename cpp_dec_float::exponent_type t = result.order(); + using local_cpp_dec_float_type = cpp_dec_float; + using local_exponent_type = typename local_cpp_dec_float_type::exponent_type; + + local_exponent_type t { result.order() }; + BOOST_MP_USING_ABS - if (abs(t) < ((std::numeric_limits::exponent_type>::max)() / 1000)) + if (abs(t) < ((std::numeric_limits::max)() / 1000)) { t *= 1000; t /= 301; @@ -3452,55 +3472,65 @@ inline void eval_frexp(cpp_dec_float& result, t *= 1000; } - result *= cpp_dec_float::pow2(-t); + result *= local_cpp_dec_float_type::pow2(-t); if (result.iszero() || (result.isinf)() || (result.isnan)()) { // pow2 overflowed, slip the calculation up: result = x; - if (result.isneg()) + if (b_neg) result.negate(); t /= 2; - result *= cpp_dec_float::pow2(-t); + result *= local_cpp_dec_float_type::pow2(-t); } BOOST_MP_USING_ABS if (abs(result.order()) > 5) { // If our first estimate doesn't get close enough then try recursion until we do: - typename cpp_dec_float::exponent_type e2; - cpp_dec_float r2; + local_exponent_type e2; + cpp_dec_float r2; eval_frexp(r2, result, &e2); // overflow protection: - if ((t > 0) && (e2 > 0) && (t > (std::numeric_limits::exponent_type>::max)() - e2)) + if ((t > 0) && (e2 > 0) && (t > (std::numeric_limits::max)() - e2)) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); - if ((t < 0) && (e2 < 0) && (t < (std::numeric_limits::exponent_type>::min)() - e2)) + if ((t < 0) && (e2 < 0) && (t < (std::numeric_limits::min)() - e2)) BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); t += e2; result = r2; } - while (result.compare(cpp_dec_float::one()) >= 0) + while (result.compare(local_cpp_dec_float_type::one()) >= 0) { - result /= cpp_dec_float::two(); + result /= local_cpp_dec_float_type::two(); ++t; } - while (result.compare(cpp_dec_float::half()) < 0) + while (result.compare(local_cpp_dec_float_type::half()) < 0) { - result *= cpp_dec_float::two(); + result *= local_cpp_dec_float_type::two(); --t; } *e = t; - if (x.isneg()) + if (b_neg) result.negate(); } template inline typename std::enable_if< !std::is_same::value>::type eval_frexp(cpp_dec_float& result, const cpp_dec_float& x, int* e) { - typename cpp_dec_float::exponent_type t; + using local_exponent_type = typename cpp_dec_float::exponent_type; + + local_exponent_type t { }; + eval_frexp(result, x, &t); - if ((t > (std::numeric_limits::max)()) || (t < (std::numeric_limits::min)())) + + using local_common_type = typename std::common_type::type; + + if ( (static_cast(t) > static_cast((std::numeric_limits::max)())) + || (static_cast(t) < static_cast((std::numeric_limits::min)()))) + { BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int")); + } + *e = static_cast(t); } diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index dde4531c7..8e26f07aa 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -643,7 +643,6 @@ namespace local return result_of_trip_is_ok; } - template auto test_cpp_dec_float_rd_ovf_unf() -> void { @@ -739,6 +738,54 @@ namespace local BOOST_TEST(((boost::multiprecision::fpclassify)(min_neg_03) == FP_ZERO) && (!signbit(min_neg_03))); } } + + template + auto test_cpp_dec_float_frexp_edge() -> void + { + using float_type = CppDecFloatType; + + using float_backend_ctrl_type = boost::multiprecision::cpp_bin_float<50, boost::multiprecision::digit_base_10, void, std::int32_t>; + + using float_ctrl_type = boost::multiprecision::number; + + std::mt19937_64 gen { time_point() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.01F), + static_cast(1.04F) + }; + + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(32)); ++index) + { + static_cast(index); + + using local_exponent_type = typename float_type::backend_type::exponent_type; + + local_exponent_type exp_val { }; + std::int32_t exp_val_ctrl { }; + + float_type arg_near_max { (std::numeric_limits::max)() / dis(gen) }; + + const bool is_neg { ((index & 1U) != 0U) }; + + if(is_neg) + { + arg_near_max = -arg_near_max; + } + + float_type frexp_near_max { frexp(arg_near_max, &exp_val) }; + const float_ctrl_type frexp_near_max_ctrl { frexp(float_ctrl_type(arg_near_max), &exp_val_ctrl) }; + + BOOST_TEST((boost::multiprecision::isfinite)(frexp_near_max)); + BOOST_TEST(exp_val >= (std::numeric_limits::max_exponent - 8)); + BOOST_TEST(exp_val == exp_val_ctrl); + BOOST_TEST(is_close_fraction(float_type(frexp_near_max_ctrl), frexp_near_max, std::numeric_limits::epsilon() * 8)); + } + } + } } // namespace local auto main() -> int @@ -763,6 +810,7 @@ auto main() -> int static_cast(local::test_edges()); local::test_cpp_dec_float_rd_ovf_unf(); local::test_convert_and_back(0.0F); + local::test_cpp_dec_float_frexp_edge(); } { From 885e2d9a973cf0ac0064586841ffa994050eebec Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 5 Jul 2025 15:51:57 +0200 Subject: [PATCH 011/114] Finish dec_float coverage for now --- .../boost/multiprecision/cpp_dec_float.hpp | 52 +++++++++++-------- test/test_various_edges_more.cpp | 4 +- 2 files changed, 33 insertions(+), 23 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 8583bea92..283c317d3 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1948,13 +1948,13 @@ std::string cpp_dec_float::str(std::intmax_t if (number_of_digits) { my_str.insert(static_cast(0), std::string::size_type(number_of_digits), '0'); - have_leading_zeros = true; + have_leading_zeros = true; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. } } if (number_of_digits < 0) { - my_str = "0"; + my_str = "0"; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. if (isneg()) my_str.insert(static_cast(0), 1, '-'); boost::multiprecision::detail::format_float_string(my_str, 0, number_of_digits - my_exp - 1, f, this->iszero()); @@ -2036,7 +2036,7 @@ std::string cpp_dec_float::str(std::intmax_t } else { - my_str = "1"; + my_str = "1"; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. ++my_exp; } } @@ -2089,7 +2089,7 @@ bool cpp_dec_float::rd_string(const char* con exp = boost::lexical_cast(static_cast(my_str.c_str() + (pos + 1u))); #else if (my_str.find_first_not_of(valid_characters, ((my_str[pos + 1] == '+') || (my_str[pos + 1] == '-')) ? pos + 2 : pos + 1) != std::string::npos) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // LCOV_EXCL_LINE exp = static_cast(std::atoll(static_cast(my_str.c_str() + (pos + 1u)))); #endif @@ -2165,9 +2165,9 @@ bool cpp_dec_float::rd_string(const char* con { // Check we have only digits either side of the point: if (my_str.find_first_not_of(valid_characters) != pos) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // LCOV_EXCL_LINE if (my_str.find_first_not_of(valid_characters, pos + 1) != std::string::npos) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // LCOV_EXCL_LINE // Remove all trailing insignificant zeros. const std::string::const_reverse_iterator rit_non_zero = std::find_if(my_str.rbegin(), my_str.rend(), char_is_nonzero_predicate); @@ -2216,7 +2216,7 @@ bool cpp_dec_float::rd_string(const char* con { // We should have only digits: if (my_str.find_first_not_of(valid_characters) != std::string::npos) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); // LCOV_EXCL_LINE // Input string has no decimal point: Append decimal point. my_str.append("."); @@ -2280,7 +2280,7 @@ bool cpp_dec_float::rd_string(const char* con // Throws an error for a strange construction like 3.14L if(pos != std::string::npos && (my_str.back() == 'L' || my_str.back() == 'l' || my_str.back() == 'u' || my_str.back() == 'U')) { - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with an integer literal")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with an integer literal")); // LCOV_EXCL_LINE } const std::int32_t n_dec = static_cast(static_cast(my_str.length() - 1u) - static_cast(pos)); @@ -2396,18 +2396,30 @@ cpp_dec_float::cpp_dec_float(const double man // Create *this cpp_dec_float from a given mantissa and exponent. // Note: This constructor does not maintain the full precision of double. - const bool mantissa_is_iszero = (::fabs(mantissa) < ((std::numeric_limits::min)() * (1.0 + std::numeric_limits::epsilon()))); + std::fill(data.begin(), data.end(), static_cast(0u)); + + constexpr double + dbl_min_check + { + static_cast + ( + (std::numeric_limits::min)() * (1.0 + std::numeric_limits::epsilon()) + ) + }; + + using std::fabs; + + const bool mantissa_is_iszero = (fabs(mantissa) < dbl_min_check); if (mantissa_is_iszero) { - std::fill(data.begin(), data.end(), static_cast(0u)); return; } - const bool b_neg = (mantissa < 0.0); + const bool b_neg { (mantissa < 0.0) }; - double d = ((!b_neg) ? mantissa : -mantissa); - exponent_type e = exponent; + double d { ((!b_neg) ? mantissa : -mantissa) }; + exponent_type e { exponent }; while (d > 10.0) { @@ -2431,8 +2443,6 @@ cpp_dec_float::cpp_dec_float(const double man exp = e; neg = b_neg; - std::fill(data.begin(), data.end(), static_cast(0u)); - constexpr std::int32_t digit_ratio = static_cast(static_cast(std::numeric_limits::digits10) / static_cast(cpp_dec_float_elem_digits10)); constexpr std::int32_t digit_loops = static_cast(digit_ratio + static_cast(2)); @@ -3408,7 +3418,7 @@ inline void eval_ldexp(cpp_dec_float& result, if ( (static_cast(the_exp) > static_cast((std::numeric_limits::max)())) || (static_cast(the_exp) < static_cast((std::numeric_limits::min)()))) { - BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Exponent value is out of range."))); + BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Exponent value is out of range."))); // LCOV_EXCL_LINE } result = x; @@ -3492,21 +3502,21 @@ inline void eval_frexp(cpp_dec_float& result, eval_frexp(r2, result, &e2); // overflow protection: if ((t > 0) && (e2 > 0) && (t > (std::numeric_limits::max)() - e2)) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); // LCOV_EXCL_LINE if ((t < 0) && (e2 < 0) && (t < (std::numeric_limits::min)() - e2)) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2.")); // LCOV_EXCL_LINE t += e2; result = r2; } while (result.compare(local_cpp_dec_float_type::one()) >= 0) { - result /= local_cpp_dec_float_type::two(); + result.div_unsigned_long_long(2ULL); ++t; } while (result.compare(local_cpp_dec_float_type::half()) < 0) { - result *= local_cpp_dec_float_type::two(); + result.mul_unsigned_long_long(2ULL); --t; } *e = t; @@ -3528,7 +3538,7 @@ inline typename std::enable_if< !std::is_same::value>::type e if ( (static_cast(t) > static_cast((std::numeric_limits::max)())) || (static_cast(t) < static_cast((std::numeric_limits::min)()))) { - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int")); // LCOV_EXCL_LINE } *e = static_cast(t); diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 8e26f07aa..d37d95d9b 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -363,8 +363,8 @@ namespace local infty_strings_list { std::string("inf"), std::string("INF"), std::string("infinity"), std::string("INFINITY"), - std::string("+inf"), std::string("+INF"), std::string("+infinity"), std::string("+INFINITY"), - std::string("-inf"), std::string("-INF"), std::string("-infinity"), std::string("-INFINITY") + std::string("+inf"), std::string("+INF"), std::string("+infinity"), std::string("+INFINITY"), + std::string("-inf"), std::string("-INF"), std::string("-infinity"), std::string("-INFINITY") }; const std::vector infty_strings(infty_strings_list); From 40fede4b5dd511b28a41d4f4743d3b1efc6ee58d Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 5 Jul 2025 20:23:44 +0200 Subject: [PATCH 012/114] Finish dec_float cover and comments --- include/boost/multiprecision/cpp_dec_float.hpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 283c317d3..382d741d6 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -70,7 +70,7 @@ struct number_category -class cpp_dec_float +class cpp_dec_float // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. { private: // Perform some static sanity checks. @@ -157,7 +157,7 @@ class cpp_dec_float a.prec_elem = cpp_dec_float_elem_number; return a; - } // LCOV_EXCL_LINE + } // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. public: // Public Constructors @@ -1167,7 +1167,7 @@ cpp_dec_float& cpp_dec_float(n); @@ -2453,7 +2453,7 @@ cpp_dec_float::cpp_dec_float(const double man d -= static_cast(n); d *= static_cast(cpp_dec_float_elem_mask); } -} // LCOV_EXCL_LINE +} // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. template template @@ -3158,7 +3158,7 @@ cpp_dec_float cpp_dec_float::two(), static_cast(p), std::integral_constant()); return t; -} // LCOV_EXCL_LINE +} // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. template inline void eval_add(cpp_dec_float& result, const cpp_dec_float& o) @@ -3443,7 +3443,7 @@ inline void eval_ldexp(cpp_dec_float& result, if (2 * half_exp != e) t *= 2; result *= t; - } // LCOV_EXCL_LINE + } // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. else result *= local_cpp_dec_float_type::pow2(e); } From 4f4783636142e9872e871d598fd321f1ea500db5 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 6 Jul 2025 14:07:23 +0200 Subject: [PATCH 013/114] Annotate and slight rework some tests for cover --- test/git_issue_167.cpp | 33 +++++++++++++++++------ test/test_atan.cpp | 45 +++++++++++++++++++------------- test/test_cpp_bin_float_conv.cpp | 25 +++++++++++++----- test/test_cpp_int.cpp | 13 ++++++--- test/test_float_io.cpp | 6 +++++ 5 files changed, 85 insertions(+), 37 deletions(-) diff --git a/test/git_issue_167.cpp b/test/git_issue_167.cpp index ddfc91fac..9b0c52716 100644 --- a/test/git_issue_167.cpp +++ b/test/git_issue_167.cpp @@ -1,23 +1,40 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright 2019 John Maddock. Distributed under the Boost +// Copyright 2019 - 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. +// 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) +#include + #include -#include "test.hpp" + +#include +#include int main() { - try{ + std::string str { }; + + try + { + using local_dec_float_type = boost::multiprecision::cpp_dec_float_50; + std::locale::global(std::locale("en-US")); - boost::multiprecision::cpp_dec_float_50 d("1234.56"); - std::string s = d.str(); + local_dec_float_type d("1234.56"); + str = d.str(); + + BOOST_CHECK_EQUAL(str, "1234.56"); - BOOST_CHECK_EQUAL(s, "1234.56"); + d = local_dec_float_type("123.456"); + str = d.str(); + + BOOST_CHECK_EQUAL(str, "123.456"); } catch(const std::runtime_error&){} // No en-US locale + BOOST_CHECK(!str.empty()); + BOOST_CHECK(str.find('.') != std::string::npos); + return boost::report_errors(); } - - diff --git a/test/test_atan.cpp b/test/test_atan.cpp index 8c9ab2d87..893061eb6 100644 --- a/test/test_atan.cpp +++ b/test/test_atan.cpp @@ -13,9 +13,11 @@ #define _SCL_SECURE_NO_WARNINGS #endif +#include + #include + #include -#include "test.hpp" #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DOUBLE_FLOAT) #define TEST_MPF_50 @@ -73,11 +75,16 @@ T atan2_def(T y, T x) T t; t.backend() = boost::multiprecision::default_ops::get_constant_pi(); T t2; - if (x) + if (x != 0) + { t2 = atan(y / x); + t2 += T((t / 2) * (1 - x.sign()) * T(y.sign() + 0.5).sign()); + } else + { t2 = y.sign() * t / 2; - return t2 + (t / 2) * (1 - x.sign()) * T(y.sign() + 0.5).sign(); + } + return t2; } template @@ -158,13 +165,13 @@ void test() T e = relative_error(val, T(data[k])); unsigned err = e.template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. val = atan(-arg); e = relative_error(val, T(-T(data[k]))); err = e.template convert_to(); if (err > max_err) { - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } arg *= 10000; } @@ -184,28 +191,28 @@ void test() err = e.template convert_to(); if (err > max_err) { - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } val = atan2(-arg, 1); e = relative_error(val, atan2_def(T(-arg), T(1))); err = e.template convert_to(); if (err > max_err) { - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } val = atan2(arg, -1); e = relative_error(val, atan2_def(arg, T(-1))); err = e.template convert_to(); if (err > max_err) { - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } val = atan2(-arg, -1); e = relative_error(val, atan2_def(T(-arg), T(-1))); err = e.template convert_to(); if (err > max_err) { - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } arg *= 10000; } @@ -214,13 +221,13 @@ void test() // err = relative_error(T(atan2(T(0), T(1))), atan2_def(T(0), T(1))).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. if (!boost::multiprecision::is_interval_number::value) { // We don't test this with intervals as [-0,0] leads to strange behaviour in atan2... err = relative_error(T(atan2(T(0), T(-1))), atan2_def(T(0), T(-1))).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } T pi; @@ -228,29 +235,31 @@ void test() err = relative_error(T(atan2(T(1), T(0))), T(pi / 2)).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. err = relative_error(T(atan2(T(-1), T(0))), T(pi / -2)).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. T mv = (std::numeric_limits::max)(); - err = relative_error(T(atan2(mv, T(1))), T(pi / 2)).template convert_to(); + err = relative_error(T(atan2(mv, T(1))), T(pi / 2)).template convert_to(); + err = relative_error(T(atan2(mv, T(1))), atan2_def(T(mv), T(1))).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. err = relative_error(T(atan2(-mv, T(1))), T(pi / -2)).template convert_to(); + err = relative_error(T(atan2(-mv, T(1))), atan2_def(T(-mv), T(0))).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. if (std::numeric_limits::has_infinity) { mv = (std::numeric_limits::infinity)(); err = relative_error(T(atan2(mv, T(1))), T(pi / 2)).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. err = relative_error(T(atan2(-mv, T(1))), T(pi / -2)).template convert_to(); if (err > max_err) - max_err = err; + max_err = err; // LCOV_EXCL_LINE This line might not necessarily be expected to get hit in tests. } std::cout << "Max error was: " << max_err << std::endl; diff --git a/test/test_cpp_bin_float_conv.cpp b/test/test_cpp_bin_float_conv.cpp index 70412e743..9f26a7061 100644 --- a/test/test_cpp_bin_float_conv.cpp +++ b/test/test_cpp_bin_float_conv.cpp @@ -1,5 +1,7 @@ /////////////////////////////////////////////////////////////// -// Copyright 2012 John Maddock. Distributed under the Boost +// Copyright 2012 - 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. +// Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt // @@ -8,14 +10,15 @@ #define _SCL_SECURE_NO_WARNINGS #endif +#include + #include -#include -#include "test.hpp" -#include #include #include #include + +#include #include template @@ -48,6 +51,7 @@ void check_round(const T& val, bool check_extended = false) if (diff2 < diff1) { // Some debugging code here... + // LCOV_EXCL_START These lines are not expected to get hit in tests. std::cout << val.str() << std::endl; std::cout << std::setprecision(18); std::cout << d1 << std::endl; @@ -55,14 +59,19 @@ void check_round(const T& val, bool check_extended = false) std::cout << diff1 << std::endl; std::cout << diff2 << std::endl; d1 = val.template convert_to(); + // LCOV_EXCL_STOP These lines are not expected to get hit in tests. } + + using std::signbit; + BOOST_CHECK(diff2 >= diff1); - BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(d1)); + // Note: Ask John if boost::multiprecision::signbit() should return bool? + BOOST_CHECK_EQUAL((boost::math::signbit(val) != 0), signbit(d1)); float f1 = val.template convert_to(); float f2 = boost::math::nextafter(f1, f1 < val ? FLT_MAX : -FLT_MAX); BOOST_CHECK(((abs(f1 - val) <= abs(f2 - val)))); - BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(f1)); + BOOST_CHECK_EQUAL((boost::math::signbit(val) != 0), signbit(f1)); #if !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) @@ -78,6 +87,7 @@ void check_round(const T& val, bool check_extended = false) if (diff2 < diff1) { // Some debugging code here... + // LCOV_EXCL_START These lines are not expected to get hit in tests. std::cout << val.str() << std::endl; std::cout << std::setprecision(18); std::cout << l1 << std::endl; @@ -85,9 +95,10 @@ void check_round(const T& val, bool check_extended = false) std::cout << diff1 << std::endl; std::cout << diff2 << std::endl; l1 = val.template convert_to(); + // LCOV_EXCL_STOP These lines are not expected to get hit in tests. } BOOST_CHECK(diff2 >= diff1); - BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(l1)); + BOOST_CHECK_EQUAL((boost::math::signbit(val) != 0), signbit(l1)); } #endif diff --git a/test/test_cpp_int.cpp b/test/test_cpp_int.cpp index d28b7a1b2..194c9e2c5 100644 --- a/test/test_cpp_int.cpp +++ b/test/test_cpp_int.cpp @@ -1,5 +1,7 @@ /////////////////////////////////////////////////////////////// -// Copyright 2012 John Maddock. Distributed under the Boost +// Copyright 2012 - 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. +// Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt @@ -17,12 +19,13 @@ // #define BOOST_MP_USE_LIMB_SHIFT -#include +#include +#include + #include +#include #include #include -#include "timer.hpp" -#include "test.hpp" #ifdef _MSC_VER #pragma warning(disable : 4127) // Conditional expression is constant @@ -785,6 +788,7 @@ struct tester if (last_error_count != (unsigned)boost::detail::test_errors()) { + // LCOV_EXCL_START These lines are not expected to get hit in tests. last_error_count = boost::detail::test_errors(); std::cout << std::hex << std::showbase; @@ -817,6 +821,7 @@ struct tester std::cout << "a1%b1 = " << a1 % b1 << std::endl; std::cout << "a%d = " << a % d << std::endl; std::cout << "a1%d1 = " << a1 % d1 << std::endl; + // LCOV_EXCL_STOP These lines are not expected to get hit in tests. } // diff --git a/test/test_float_io.cpp b/test/test_float_io.cpp index 04d0ca469..b0621ce32 100644 --- a/test/test_float_io.cpp +++ b/test/test_float_io.cpp @@ -109,6 +109,7 @@ bool is_bankers_rounding_error(const std::string& s, const char* expect) return true; } +// LCOV_EXCL_START These lines are not expected to get hit in tests. void print_flags(std::ios_base::fmtflags f) { std::cout << "Formatting flags were: "; @@ -122,6 +123,7 @@ void print_flags(std::ios_base::fmtflags f) std::cout << "showpos "; std::cout << std::endl; } +// LCOV_EXCL_STOP These lines are not expected to get hit in tests. template void test() @@ -162,6 +164,7 @@ void test() } else { + // LCOV_EXCL_START These lines are not expected to get hit in tests. std::cout << std::setprecision(20) << "Testing value " << val << std::endl; print_flags(f[i]); std::cout << "Precision is: " << prec << std::endl; @@ -169,6 +172,7 @@ void test() std::cout << "Expected: " << expect << std::endl; ++boost::detail::test_errors(); mp_t(val).str(prec, f[i]); // for debugging + // LCOV_EXCL_STOP These lines are not expected to get hit in tests. } } } @@ -195,6 +199,7 @@ void test() const char* expect = zeros[col]; if (ss.str() != expect) { + // LCOV_EXCL_START These lines are not expected to get hit in tests. std::cout << std::setprecision(20) << "Testing value " << val << std::endl; print_flags(f[i]); std::cout << "Precision is: " << prec << std::endl; @@ -202,6 +207,7 @@ void test() std::cout << "Expected: " << expect << std::endl; ++boost::detail::test_errors(); mp_t(val).str(prec, f[i]); // for debugging + // LCOV_EXCL_STOP These lines are not expected to get hit in tests. } } } From 14f4212c02121abc7706e3ec9bff64cf26448266 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 6 Jul 2025 19:00:22 +0200 Subject: [PATCH 014/114] Repair and cover test for issue167 --- test/git_issue_167.cpp | 38 ++++++++++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/test/git_issue_167.cpp b/test/git_issue_167.cpp index 9b0c52716..82adfc75b 100644 --- a/test/git_issue_167.cpp +++ b/test/git_issue_167.cpp @@ -20,21 +20,39 @@ int main() { using local_dec_float_type = boost::multiprecision::cpp_dec_float_50; - std::locale::global(std::locale("en-US")); - local_dec_float_type d("1234.56"); - str = d.str(); + // Test a string with a decimal point. + local_dec_float_type d_first("1234.56"); + str = d_first.str(); + BOOST_CHECK(str == "1234.56"); - BOOST_CHECK_EQUAL(str, "1234.56"); + // Set a new local locale. + #if (defined(__GNUC__) && defined(__x86_64__)) + // We really want to pick up these lines on GHA coverage runners. + const char* p_str_loc = std::setlocale(LC_ALL, "C.UTF-8"); + #else + const char* p_str_loc = std::setlocale(LC_ALL, "en_US.UTF-8"); + #endif - d = local_dec_float_type("123.456"); - str = d.str(); + std::cout << "A local locale was set: " << p_str_loc << std::endl; - BOOST_CHECK_EQUAL(str, "123.456"); + { + std::stringstream strm { }; + + strm << p_str_loc; + + // Check the new local locale. + BOOST_CHECK(strm.str().find("UTF") != std::string::npos); + } + + // Test another string with a decimal point. + local_dec_float_type d_other("123.789"); + str = d_other.str(); + + BOOST_CHECK(str == "123.789"); } - catch(const std::runtime_error&){} // No en-US locale + catch(const std::runtime_error&) { } // LCOV_EXCL_LINE No locale was found. - BOOST_CHECK(!str.empty()); - BOOST_CHECK(str.find('.') != std::string::npos); + BOOST_CHECK(str == "123.789"); return boost::report_errors(); } From 4f1bae2869f1e40acad36cf9889ae406ecd88b26 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 6 Jul 2025 21:31:37 +0200 Subject: [PATCH 015/114] Continue patching issue167 and get cover --- test/git_issue_167.cpp | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/test/git_issue_167.cpp b/test/git_issue_167.cpp index 82adfc75b..ec53141ed 100644 --- a/test/git_issue_167.cpp +++ b/test/git_issue_167.cpp @@ -16,6 +16,9 @@ int main() { std::string str { }; + // Test strings with a decimal point. Keep in the spirit of the + // original test case. But don't simply try-catch out of it. + try { using local_dec_float_type = boost::multiprecision::cpp_dec_float_50; @@ -25,13 +28,14 @@ int main() str = d_first.str(); BOOST_CHECK(str == "1234.56"); - // Set a new local locale. - #if (defined(__GNUC__) && defined(__x86_64__)) - // We really want to pick up these lines on GHA coverage runners. + #if (defined(__GNUC__) && defined(__x86_64__) && !defined(WIN32) && !defined(__APPLE__)) + + // Set a new local locale. All these compilers have different + // locale names. In this particular case, we stay with the + // original spirit of the test in issue167 at least on Ubuntu + // GHA runners. We also wanto to pick up these lines of coverage. + const char* p_str_loc = std::setlocale(LC_ALL, "C.UTF-8"); - #else - const char* p_str_loc = std::setlocale(LC_ALL, "en_US.UTF-8"); - #endif std::cout << "A local locale was set: " << p_str_loc << std::endl; @@ -43,8 +47,8 @@ int main() // Check the new local locale. BOOST_CHECK(strm.str().find("UTF") != std::string::npos); } + #endif - // Test another string with a decimal point. local_dec_float_type d_other("123.789"); str = d_other.str(); From 912326798e1de7b6b9b74743a187faeda76401a7 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 6 Jul 2025 22:55:16 +0200 Subject: [PATCH 016/114] Exclude set-locale on __MINGW__ runners --- test/git_issue_167.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/git_issue_167.cpp b/test/git_issue_167.cpp index ec53141ed..469f4d35f 100644 --- a/test/git_issue_167.cpp +++ b/test/git_issue_167.cpp @@ -28,7 +28,10 @@ int main() str = d_first.str(); BOOST_CHECK(str == "1234.56"); - #if (defined(__GNUC__) && defined(__x86_64__) && !defined(WIN32) && !defined(__APPLE__)) + #if (defined(__GNUC__) && defined(__x86_64__) && !(defined(_WIN32) || defined(__MINGW32__)) && !defined(__APPLE__)) + + // That preprocessor line is detailed, but it really essentially is + // just trying to isolate Ubuntu runners on GHA for test and coverage. // Set a new local locale. All these compilers have different // locale names. In this particular case, we stay with the From d9fe99069ace430391ff43595fd91e65a45da02c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 7 Jul 2025 10:38:16 +0200 Subject: [PATCH 017/114] Improve and run tests issue464 --- test/Jamfile.v2 | 1 + test/git_issue_464.cpp | 37 +++++++++++++++++++++++++++++++++---- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 8bb53c7c0..71463828a 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -1257,6 +1257,7 @@ test-suite misc : [ run git_issue_426.cpp : : : [ check-target-builds ../config//has_mpfr : gmp mpfr TEST_MPFR ] [ check-target-builds ../config//has_float128 : quadmath TEST_FLOAT128 ] ] [ run git_issue_277.cpp ] [ run git_issue_313.cpp ] + [ run git_issue_464.cpp ] [ run git_issue_488.cpp ] [ run git_issue_506.cpp ] [ run git_issue_509.cpp : : : [ requires cpp_lib_bit_cast ] ] diff --git a/test/git_issue_464.cpp b/test/git_issue_464.cpp index dc9d0054a..efe082074 100644 --- a/test/git_issue_464.cpp +++ b/test/git_issue_464.cpp @@ -1,24 +1,53 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright 2022 Matt Borland. Distributed under the Boost +// Copyright 2022 - 2025 Matt Borland. +// Copyright 2025 Christopher Kormanyos. +// 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) // // See: https://github.com/boostorg/multiprecision/issues/464 +#include + #include -#include -#include "test.hpp" + +#include +#include template void test() { - auto a = boost::multiprecision::cpp_dec_float_50 {12345}; + auto a = boost::multiprecision::cpp_dec_float_50 { 12345 }; auto d1 = a.convert_to(); + { + std::stringstream strm { }; + strm.imbue(std::locale::classic()); + strm << std::scientific << std::setprecision(8) << d1; + + BOOST_CHECK(strm.str().find("1.2345") != std::string::npos); + } + + #if defined(BOOST_MSVC) + // Ubuntu runners did not have this locale in GCC. + // Windows runners seem like they do have this locale in MSVC. + // I did not check any others + + // Set a different locale. std::locale::global(std::locale("de_DE")); + #endif + auto d2 = a.convert_to(); + { + std::stringstream strm { }; + strm.imbue(std::locale::classic()); + strm << std::scientific << std::setprecision(8) << d2; + + BOOST_CHECK(strm.str().find("1.2345") != std::string::npos); + } + BOOST_CHECK_EQUAL(d1, d2); } From cef08fae9470619cbd77b93e9fdeefa6d3df7a0a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 7 Jul 2025 16:40:20 +0200 Subject: [PATCH 018/114] More tests and repair edge case pow --- .../boost/multiprecision/cpp_double_fp.hpp | 49 ++++++++++++++----- test/test_sf_import_c99.cpp | 29 ++++++++--- 2 files changed, 60 insertions(+), 18 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 22b79b671..c5924dfc7 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1479,10 +1479,6 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const result = one; } - else if (fpc_a == FP_NAN) - { - result = double_float_type::my_value_nan(); - } else if (fpc_x == FP_ZERO) { if ((fpc_a == FP_NORMAL) || (fpc_a == FP_INFINITE)) @@ -1495,6 +1491,10 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const result = (eval_signbit(a) ? double_float_type::my_value_inf() : zero); } + else if (fpc_a == FP_NAN) + { + result = double_float_type::my_value_nan(); + } } else if (fpc_x == FP_INFINITE) { @@ -1505,6 +1505,10 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const result = (eval_signbit(a) ? zero : double_float_type::my_value_inf()); } + else if (fpc_a == FP_NAN) + { + result = double_float_type::my_value_nan(); + } } else if (fpc_x != FP_NORMAL) { @@ -1512,14 +1516,37 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const } else { - if (fpc_a == FP_INFINITE) + if (fpc_a == FP_ZERO) { - result = - ( - (x.compare(one) == -1) ? (eval_signbit(a) ? double_float_type::my_value_inf() : zero) - : (x.compare(one) == +1) ? (eval_signbit(a) ? zero : double_float_type::my_value_inf()) - : one - ); + result = one; + } + else if (fpc_a == FP_INFINITE) + { + constexpr double_float_type one_minus { -1 }; + + if (x.compare(one_minus) == 0) + { + result = one; + } + else + { + double_float_type xabs { }; + + eval_fabs(xabs, x); + + const int compare_one_result { xabs.compare(one) }; + + result = + ( + (compare_one_result < 0) ? (eval_signbit(a) ? double_float_type::my_value_inf() : zero) + : (compare_one_result > 0) ? (eval_signbit(a) ? zero : double_float_type::my_value_inf()) + : one + ); + } + } + else if (fpc_a == FP_NAN) + { + result = (x.compare(one) == 0) ? one : double_float_type::my_value_nan(); } else { diff --git a/test/test_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index 457c87c45..a9e44dced 100644 --- a/test/test_sf_import_c99.cpp +++ b/test/test_sf_import_c99.cpp @@ -638,51 +638,59 @@ void test_poison() } template -bool type_sets_errno(const T&) +static bool type_sets_errno(const T&) { return true; } #ifdef TEST_MPFR_50 template -bool type_sets_errno(const boost::multiprecision::number, ExpressionTemplates>&) +static bool type_sets_errno(const boost::multiprecision::number, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFR_DEBUG_ADAPTOR template -bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFI_DEBUG_ADAPTOR template -bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFR_LOGGED_ADAPTOR template -bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFI_LOGGED_ADAPTOR template -bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_FLOAT128 -bool type_sets_errno(const boost::multiprecision::float128&) +static bool type_sets_errno(const boost::multiprecision::float128&) { return false; } #endif +#ifdef TEST_CPP_DOUBLE_FLOAT +static bool type_sets_errno(const boost::multiprecision::cpp_double_float&) { return false; } +static bool type_sets_errno(const boost::multiprecision::cpp_double_double&) { return false; } +static bool type_sets_errno(const boost::multiprecision::cpp_double_long_double&) { return false; } +#if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) +static bool type_sets_errno(const boost::multiprecision::cpp_double_float128&) { return false; } +#endif +#endif template typename std::enable_if::is_specialized>::type check_invalid(const T& val) @@ -2263,6 +2271,7 @@ int main() #endif #endif #ifdef TEST_CPP_BIN_FLOAT + test_c99_appendix_F(); test(); test, boost::multiprecision::et_on> >(); #endif @@ -2297,8 +2306,14 @@ int main() #ifdef TEST_CPP_DOUBLE_FLOAT test(); test(); + + test_c99_appendix_F(); + test_c99_appendix_F(); + #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); + + test_c99_appendix_F(); #endif #endif From 600568762c30623b3c8f2f9a0f6e14092da70344 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 7 Jul 2025 18:33:06 +0200 Subject: [PATCH 019/114] Revert test needing slight backend repairs --- test/test_sf_import_c99.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/test/test_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index a9e44dced..83f9a23ea 100644 --- a/test/test_sf_import_c99.cpp +++ b/test/test_sf_import_c99.cpp @@ -2271,7 +2271,6 @@ int main() #endif #endif #ifdef TEST_CPP_BIN_FLOAT - test_c99_appendix_F(); test(); test, boost::multiprecision::et_on> >(); #endif From f5d4bbf8153ef28b7de95096b4885dfc5f4978f5 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 7 Jul 2025 19:54:22 +0200 Subject: [PATCH 020/114] Minor corrections selected C99 edge cases --- .../multiprecision/detail/default_ops.hpp | 38 +++++++++++++++++-- test/test_sf_import_c99.cpp | 31 ++++++++------- 2 files changed, 52 insertions(+), 17 deletions(-) diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index 0e8debe1e..5a17e78f6 100644 --- a/include/boost/multiprecision/detail/default_ops.hpp +++ b/include/boost/multiprecision/detail/default_ops.hpp @@ -2619,6 +2619,15 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number& arg) { + using local_number_type = multiprecision::number; + + const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; + + if (fpc_arg == FP_ZERO) + { + return arg; + } + detail::scoped_default_precision > precision_guard(arg); return boost::math::erf(arg, c99_error_policy()); } @@ -2626,7 +2635,15 @@ template inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression::result_type erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression& arg) { using value_type = typename multiprecision::detail::expression::result_type; - detail::scoped_default_precision precision_guard(arg); + detail::scoped_default_precision precision_guard(arg); + + const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; + + if (fpc_arg == FP_ZERO) + { + return arg; + } + return erf(value_type(arg)); } template @@ -2678,12 +2695,27 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number& arg) { - detail::scoped_default_precision > precision_guard(arg); - if ((arg == 0) && std::numeric_limits >::has_infinity) + using local_number_type = multiprecision::number; + + detail::scoped_default_precision precision_guard(arg); + + const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; + + if ((fpc_arg == FP_ZERO) && std::numeric_limits::has_infinity) { errno = ERANGE; return 1 / arg; } + else if ((fpc_arg == FP_NAN) && std::numeric_limits::has_quiet_NaN) + { + return arg; + } + else if ((fpc_arg == FP_INFINITE) && std::numeric_limits::has_infinity && std::numeric_limits::has_quiet_NaN) + { + const bool is_neg { arg.compare(local_number_type(0)) < 0 }; + + return ((!is_neg) ? std::numeric_limits::infinity() : std::numeric_limits::quiet_NaN()); + } return boost::math::tgamma(arg, c99_error_policy()); } template diff --git a/test/test_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index 83f9a23ea..b085f9191 100644 --- a/test/test_sf_import_c99.cpp +++ b/test/test_sf_import_c99.cpp @@ -638,57 +638,57 @@ void test_poison() } template -static bool type_sets_errno(const T&) +static constexpr bool type_sets_errno(const T&) { return true; } #ifdef TEST_MPFR_50 template -static bool type_sets_errno(const boost::multiprecision::number, ExpressionTemplates>&) +static constexpr bool type_sets_errno(const boost::multiprecision::number, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFR_DEBUG_ADAPTOR template -static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static constexpr bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFI_DEBUG_ADAPTOR template -static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static constexpr bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFR_LOGGED_ADAPTOR template -static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static constexpr bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_MPFI_LOGGED_ADAPTOR template -static bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) +static constexpr bool type_sets_errno(const boost::multiprecision::number >, ExpressionTemplates>&) { return false; } #endif #ifdef TEST_FLOAT128 -static bool type_sets_errno(const boost::multiprecision::float128&) +static constexpr bool type_sets_errno(const boost::multiprecision::float128&) { return false; } #endif #ifdef TEST_CPP_DOUBLE_FLOAT -static bool type_sets_errno(const boost::multiprecision::cpp_double_float&) { return false; } -static bool type_sets_errno(const boost::multiprecision::cpp_double_double&) { return false; } -static bool type_sets_errno(const boost::multiprecision::cpp_double_long_double&) { return false; } +static constexpr bool type_sets_errno(const boost::multiprecision::cpp_double_float&) { return false; } +static constexpr bool type_sets_errno(const boost::multiprecision::cpp_double_double&) { return false; } +static constexpr bool type_sets_errno(const boost::multiprecision::cpp_double_long_double&) { return false; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) -static bool type_sets_errno(const boost::multiprecision::cpp_double_float128&) { return false; } +static constexpr bool type_sets_errno(const boost::multiprecision::cpp_double_float128&) { return false; } #endif #endif @@ -704,7 +704,9 @@ typename std::enable_if::is_specialized>::type check_inva BOOST_CHECK_EQUAL(val, 0); } if (type_sets_errno(val)) + { BOOST_CHECK_EQUAL(errno, EDOM); + } errno = 0; } @@ -1913,15 +1915,15 @@ void test_c99_appendix_F() arg = -1; check_invalid(tgamma(arg)); arg = -std::numeric_limits::infinity(); - check_invalid(tgamma(arg)); + BOOST_CHECK((boost::multiprecision::isnan)(tgamma(arg))); arg = std::numeric_limits::infinity(); val = tgamma(arg); - BOOST_CHECK_EQUAL(val, std::numeric_limits::infinity()); + BOOST_CHECK((boost::multiprecision::isinf)(val)); } if (std::numeric_limits::has_quiet_NaN) { arg = std::numeric_limits::quiet_NaN(); - check_invalid(tgamma(arg)); + BOOST_CHECK((boost::multiprecision::isnan)(tgamma(arg))); } // F.9.6.1: arg = 0; @@ -2271,6 +2273,7 @@ int main() #endif #endif #ifdef TEST_CPP_BIN_FLOAT + test_c99_appendix_F(); test(); test, boost::multiprecision::et_on> >(); #endif From 7371ebf77d6ba55ab64f04362ae15646868eaf7f Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 7 Jul 2025 20:48:23 +0200 Subject: [PATCH 021/114] Patch tests for double-fp --- .../multiprecision/detail/default_ops.hpp | 2 -- test/test_sf_import_c99.cpp | 22 +++++++++---------- 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index 5a17e78f6..6fd4b65eb 100644 --- a/include/boost/multiprecision/detail/default_ops.hpp +++ b/include/boost/multiprecision/detail/default_ops.hpp @@ -2619,8 +2619,6 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number& arg) { - using local_number_type = multiprecision::number; - const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; if (fpc_arg == FP_ZERO) diff --git a/test/test_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index b085f9191..d8bb0ff8d 100644 --- a/test/test_sf_import_c99.cpp +++ b/test/test_sf_import_c99.cpp @@ -802,10 +802,10 @@ void test_c99_appendix_F() { arg = std::numeric_limits::infinity(); val = atan(arg); - BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg = -std::numeric_limits::infinity(); val = atan(arg); - BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } } if (std::numeric_limits::has_quiet_NaN) { @@ -842,7 +842,7 @@ void test_c99_appendix_F() arg = 0; arg2 = -2; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, boost::math::constants::pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::pi(), std::numeric_limits::epsilon() * 8); } arg = -arg; if (signbit(arg)) { @@ -864,7 +864,7 @@ void test_c99_appendix_F() arg = -2; arg2 = 0; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg2 = -arg2; if (signbit(arg2)) { @@ -874,7 +874,7 @@ void test_c99_appendix_F() arg = 2; arg2 = 0; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg2 = -arg2; if (signbit(arg2)) { @@ -886,10 +886,10 @@ void test_c99_appendix_F() arg = 2; arg2 = -std::numeric_limits::infinity(); val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, boost::math::constants::pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::pi(), std::numeric_limits::epsilon() * 8); } arg = -arg; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, -boost::math::constants::pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, -boost::math::constants::pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::pi(), std::numeric_limits::epsilon() * 8); } arg = 2; arg2 = std::numeric_limits::infinity(); val = atan2(arg, arg2); @@ -905,17 +905,17 @@ void test_c99_appendix_F() arg = std::numeric_limits::infinity(); arg2 = 2; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg = -arg; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg = std::numeric_limits::infinity(); arg2 = -2; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg = -arg; val = atan2(arg, arg2); - BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()); + BOOST_IF_CONSTEXPR (!has_poor_exp_range_or_precision_support::value) { BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi()) } else { BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::half_pi(), std::numeric_limits::epsilon() * 8); } arg = std::numeric_limits::infinity(); arg2 = -std::numeric_limits::infinity(); val = atan2(arg, arg2); From 48ec510f914b9fdd5d74d387b618b2c48df4a473 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 8 Jul 2025 19:36:56 +0200 Subject: [PATCH 022/114] Slightly refactor a private constructor --- .../boost/multiprecision/cpp_dec_float.hpp | 80 +++++++++---------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 382d741d6..e5e6ee940 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -222,7 +222,7 @@ class cpp_dec_float // LCOV_EXCL_LINE This causes a false negative on lcov cover *this = val; } - cpp_dec_float(const double mantissa, const exponent_type exponent); + cpp_dec_float(const double mantissa, const exponent_type exp10); std::size_t hash() const { @@ -2391,10 +2391,13 @@ bool cpp_dec_float::rd_string(const char* con } template -cpp_dec_float::cpp_dec_float(const double mantissa, const ExponentType exponent) +cpp_dec_float::cpp_dec_float(const double mantissa, const ExponentType exp10) { - // Create *this cpp_dec_float from a given mantissa and exponent. - // Note: This constructor does not maintain the full precision of double. + // Create *this cpp_dec_float + // from a given mantissa and base-10 exponent. It is important + // to note that this constructor does *not* maintain the full + // precision of double. It is used internally (privately), mostly + // as a first guess for Newton iteration in square root and inversion. std::fill(data.begin(), data.end(), static_cast(0u)); @@ -2407,51 +2410,48 @@ cpp_dec_float::cpp_dec_float(const double man ) }; - using std::fabs; - - const bool mantissa_is_iszero = (fabs(mantissa) < dbl_min_check); - - if (mantissa_is_iszero) - { - return; - } - const bool b_neg { (mantissa < 0.0) }; - double d { ((!b_neg) ? mantissa : -mantissa) }; - exponent_type e { exponent }; + double d_mant { ((!b_neg) ? mantissa : -mantissa) }; - while (d > 10.0) - { - d /= 10.0; - ++e; - } - while (d < 1.0) + const bool mantissa_is_non_zero { (d_mant > dbl_min_check) }; + + if (mantissa_is_non_zero) { - d *= 10.0; - --e; - } + exponent_type exp10_val { exp10 }; + + while (d_mant > 10.0) + { + d_mant /= 10.0; + ++exp10_val; + } + while (d_mant < 1.0) + { + d_mant *= 10.0; + --exp10_val; + } - std::int32_t shift = static_cast(e % static_cast(cpp_dec_float_elem_digits10)); + std::int32_t shift = static_cast(exp10_val % static_cast(cpp_dec_float_elem_digits10)); - while (static_cast(shift-- % cpp_dec_float_elem_digits10) != static_cast(0)) - { - d *= 10.0; - --e; - } + while (static_cast(shift-- % cpp_dec_float_elem_digits10) != static_cast(0)) + { + d_mant *= 10.0; + --exp10_val; + } - exp = e; - neg = b_neg; + exp = exp10_val; + neg = b_neg; - constexpr std::int32_t digit_ratio = static_cast(static_cast(std::numeric_limits::digits10) / static_cast(cpp_dec_float_elem_digits10)); - constexpr std::int32_t digit_loops = static_cast(digit_ratio + static_cast(2)); + constexpr std::int32_t digit_ratio = static_cast(static_cast(std::numeric_limits::digits10) / static_cast(cpp_dec_float_elem_digits10)); + constexpr std::int32_t digit_loops = static_cast(digit_ratio + static_cast(2)); - for (std::int32_t i = static_cast(0); i < digit_loops; i++) - { - std::uint32_t n = static_cast(static_cast(d)); - data[static_cast(i)] = static_cast(n); - d -= static_cast(n); - d *= static_cast(cpp_dec_float_elem_mask); + for (std::int32_t i = static_cast(0); i < digit_loops; i++) + { + std::uint32_t n = static_cast(static_cast(d_mant)); + data[static_cast(i)] = static_cast(n); + d_mant -= static_cast(n); + d_mant *= static_cast(cpp_dec_float_elem_mask); + } } } // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. From d2a292dd5c3c831894c4be1e9b40e66555e8f2a6 Mon Sep 17 00:00:00 2001 From: Richard Date: Thu, 10 Jul 2025 10:01:13 -0600 Subject: [PATCH 023/114] Correct reference to GMP 5.1 mpfr_class wrapper Fixes #712 --- doc/introduction.qbk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/introduction.qbk b/doc/introduction.qbk index 4eb3b5500..b7e68b400 100644 --- a/doc/introduction.qbk +++ b/doc/introduction.qbk @@ -208,7 +208,7 @@ if we were using the [mpfr_class] C++ wrapper for [mpfr] - then this expression temporaries (this is true even though [mpfr_class] does use expression templates to reduce the number of temporaries somewhat). Had we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less that 24 temporaries are created for this simple expression (note - we actually measure the number of memory allocations performed rather than -the number of temporaries directly, note also that the [mpf_class] wrapper that will be supplied with GMP-5.1 reduces the number of +the number of temporaries directly, note also that the [mpf_class] wrapper supplied with GMP-5.1 or later reduces the number of temporaries to pretty much zero). Note that if we compile with expression templates disabled and rvalue-reference support on, then actually still have no wasted memory allocations as even though temporaries are created, their contents are moved rather than copied. From d31b9b0e6cff5e5c6680a4ef4ef0069d20b881c0 Mon Sep 17 00:00:00 2001 From: Richard Date: Thu, 10 Jul 2025 10:06:01 -0600 Subject: [PATCH 024/114] Correct markup instructions Fixes #715 --- doc/html/boost_multiprecision/tut/interval.html | 2 +- doc/tutorial_interval_mpfi.qbk | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/html/boost_multiprecision/tut/interval.html b/doc/html/boost_multiprecision/tut/interval.html index e9dfce501..5ec80339d 100644 --- a/doc/html/boost_multiprecision/tut/interval.html +++ b/doc/html/boost_multiprecision/tut/interval.html @@ -32,7 +32,7 @@ There is one currently only one interval number type supported - MPFI.

- [ section:mpfi mpfi_float] + [section:mpfi mpfi_float]

Copyright © 2002-2020 John diff --git a/doc/tutorial_interval_mpfi.qbk b/doc/tutorial_interval_mpfi.qbk index 49b26de95..7d3c995b4 100644 --- a/doc/tutorial_interval_mpfi.qbk +++ b/doc/tutorial_interval_mpfi.qbk @@ -141,7 +141,7 @@ Returns `true` if `lower(a) == upper(a)`. [mpfi_eg] -[endsect] [ section:mpfi mpfi_float] +[endsect] [section:mpfi mpfi_float] [endsect] [/section:interval Interval Number Types] From 2b1c173e2e5c91e3268b41c1c1354a7a333ae145 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 11 Jul 2025 19:44:17 +0200 Subject: [PATCH 025/114] Modernize visualizer doc and maybe future plan --- doc/tutorial_visualizers.qbk | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/doc/tutorial_visualizers.qbk b/doc/tutorial_visualizers.qbk index 6e066a4bc..78a836453 100644 --- a/doc/tutorial_visualizers.qbk +++ b/doc/tutorial_visualizers.qbk @@ -1,7 +1,7 @@ [/ - Copyright 2011 - 2020 John Maddock. + Copyright 2011 - 2025 John Maddock. Copyright 2013 - 2019 Paul A. Bristow. - Copyright 2013 Christopher Kormanyos. + Copyright 2013 - 2025 Christopher Kormanyos. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at @@ -10,14 +10,14 @@ [section:visualizers Visual C++ Debugger Visualizers] -[important This section is seriously out of date compared to recent Visual C++ releases.] +[important This section is seriously out of date compared to recent Visual C++ releases. A modernization of Multiprecision's visualizers is planned for Visual Studio 2022 (and beyond). The legacy description has been maintained and is provided below.] -Let's face it debugger multiprecision numbers is hard - simply because we can't easily inspect the value of the numbers. -Visual C++ provides a partial solution in the shape of "visualizers" which provide improved views of complex data structures, -these visualizers need to be added to the `[Visualizer]` section of `autoexp.dat` located in the `Common7/Packages/Debugger` -directory of your Visual Studio installation. The actual visualizer code is in the sandbox -[@https://svn.boost.org/svn/boost/sandbox/boost_docs/subprojects/DebuggerVisualizers/multiprecision.vis.txt here] - just cut and paste the code -into your `autoexp.dat` file. +Let's face it debugging multiprecision numbers is challenging - simply because we can't easily inspect the value of the numbers. +Visual C++ provides a partial solution in the shape of "visualizers" which provide improved views of complex data structures. + +Previously, there was preliminary support for visualizers within older versions of Visual Studio. +These legacy visualizers needed to be added to the `[Visualizer]` section of `autoexp.dat` located in the `Common7/Packages/Debugger` +directory of the local Visual Studio installation. The actual visualizer code had previously been stored in the sandbox. [note These visualizers have only been tested with VC10, also given the ability of buggy visualizers to crash your Visual C++ debugger, make sure you back up `autoexp.dat` file before using these!!] From 71cd350be9f3166151c591e88164a6b68e3087ea Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 12 Jul 2025 11:00:56 +0200 Subject: [PATCH 026/114] Correct and cover cpp_double_fp pow edges --- .../boost/multiprecision/cpp_double_fp.hpp | 6 +--- test/test_pow.cpp | 29 +++++++++++++++++++ 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index c5924dfc7..844b26958 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1516,11 +1516,7 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const } else { - if (fpc_a == FP_ZERO) - { - result = one; - } - else if (fpc_a == FP_INFINITE) + if (fpc_a == FP_INFINITE) { constexpr double_float_type one_minus { -1 }; diff --git a/test/test_pow.cpp b/test/test_pow.cpp index d2897808d..ffb4b8337 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -244,6 +244,35 @@ void test() } } + BOOST_IF_CONSTEXPR(std::numeric_limits::is_specialized && std::numeric_limits::has_quiet_NaN) + { + for (int index = 0; index < 8; ++index) + { + static_cast(index); + + T inf_or_zero_arg = T(::my_zero() * dist(gen)); + + T pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); + + BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); + + inf_or_zero_arg = T(std::numeric_limits::infinity() * dist(gen)); + + pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); + + BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); + + BOOST_IF_CONSTEXPR(std::is_same::value) + { + inf_or_zero_arg = T(-std::numeric_limits::infinity() * dist(gen)); + + pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); + + BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); + } + } + } + #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) } From 1f0385a0f56d5b18ecbf0af1977f264023777f22 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 12 Jul 2025 11:39:44 +0200 Subject: [PATCH 027/114] Disable/enable new edge-tests properly --- test/test_pow.cpp | 47 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/test/test_pow.cpp b/test/test_pow.cpp index ffb4b8337..7905ce2ed 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -127,6 +127,43 @@ namespace local { } // namespace local +#if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + +// These were the only ones I checked locally at the moment that use random tests. + +template +void test_issue722() +{ + // TBD: When issue722 gets resolved, test some of the other types. + #if defined(TEST_CPP_DEC_FLOAT) + + std::mt19937_64 gen { }; + + gen.seed(static_cast(std::clock())); + + std::uniform_real_distribution + dist + ( + static_cast(1.01L), + static_cast(1.04L) + ); + + for (int index = 0; index < 8; ++index) + { + static_cast(index); + + const T inf_or_zero_arg = T(-std::numeric_limits::infinity() * dist(gen)); + + const T pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); + + BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); + } + + #endif +} + +#endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + template void test() { @@ -261,15 +298,6 @@ void test() pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); - - BOOST_IF_CONSTEXPR(std::is_same::value) - { - inf_or_zero_arg = T(-std::numeric_limits::infinity() * dist(gen)); - - pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); - - BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); - } } } @@ -351,6 +379,7 @@ int main() #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif + test_issue722(); #endif return boost::report_errors(); } From b5725b5ba8951734d51caf0f430c8fcb93b950a6 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 12 Jul 2025 16:01:21 +0200 Subject: [PATCH 028/114] Intended to address issue722 --- .../multiprecision/detail/functions/pow.hpp | 21 +++++++-- test/test_pow.cpp | 47 ++++++++++--------- test/test_sf_import_c99.cpp | 1 + 3 files changed, 44 insertions(+), 25 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 481c7e4e9..7ecee5db2 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -511,11 +511,12 @@ inline void eval_pow(T& result, const T& x, const T& a) } int type = eval_fpclassify(x); + int fpc_a = eval_fpclassify(a); switch (type) { case FP_ZERO: - switch (eval_fpclassify(a)) + switch (fpc_a) { case FP_ZERO: result = si_type(1); @@ -643,7 +644,7 @@ inline void eval_pow(T& result, const T& x, const T& a) eval_floor(result, a); // -1^INF is a special case in C99: - if ((x.compare(si_type(-1)) == 0) && (eval_fpclassify(a) == FP_INFINITE)) + if ((x.compare(si_type(-1)) == 0) && (fpc_a == FP_INFINITE)) { result = si_type(1); } @@ -661,7 +662,21 @@ inline void eval_pow(T& result, const T& x, const T& a) } else if (type == FP_INFINITE) { - result = std::numeric_limits >::infinity().backend(); + BOOST_IF_CONSTEXPR (std::numeric_limits >::has_quiet_NaN) + { + if (fpc_a == FP_NAN) + { + result = std::numeric_limits >::quiet_NaN().backend(); + } + else + { + result = std::numeric_limits >::infinity().backend(); + } + } + else + { + result = std::numeric_limits >::infinity().backend(); + } } else BOOST_IF_CONSTEXPR (std::numeric_limits >::has_quiet_NaN) { diff --git a/test/test_pow.cpp b/test/test_pow.cpp index 7905ce2ed..56f6d0d07 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -129,37 +129,37 @@ namespace local { #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) -// These were the only ones I checked locally at the moment that use random tests. +// These were the only ones I checked locally at the moment. +// TEST_MPF_50 is included because it does its has_quiet_NaN is false. +// And this helps verify the constexpr logic of test_issue722(). template void test_issue722() { - // TBD: When issue722 gets resolved, test some of the other types. - #if defined(TEST_CPP_DEC_FLOAT) - - std::mt19937_64 gen { }; + BOOST_IF_CONSTEXPR (std::numeric_limits::is_specialized && std::numeric_limits::has_infinity && std::numeric_limits::has_quiet_NaN) + { + std::mt19937_64 gen { }; - gen.seed(static_cast(std::clock())); + gen.seed(static_cast(std::clock())); - std::uniform_real_distribution - dist - ( - static_cast(1.01L), - static_cast(1.04L) - ); + std::uniform_real_distribution + dist + ( + static_cast(1.01L), + static_cast(1.04L) + ); - for (int index = 0; index < 8; ++index) - { - static_cast(index); + for (int index = 0; index < 8; ++index) + { + static_cast(index); - const T inf_or_zero_arg = T(-std::numeric_limits::infinity() * dist(gen)); + const T neg_inf = T(-std::numeric_limits::infinity() * dist(gen)); - const T pow_inf_or_zero_to_the_nan = pow(inf_or_zero_arg, std::numeric_limits::quiet_NaN() * dist(gen)); + const T pow_neg_inf_to_the_nan = pow(neg_inf, std::numeric_limits::quiet_NaN() * dist(gen)); - BOOST_CHECK((boost::multiprecision::isnan)(pow_inf_or_zero_to_the_nan)); + BOOST_CHECK((boost::multiprecision::isnan)(pow_neg_inf_to_the_nan)); + } } - - #endif } #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) @@ -208,7 +208,7 @@ void test() BOOST_CHECK_EQUAL(pow(T(1), 2), 1); #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) - // These were the only ones I checked locally at the moment that use random tests. + // These were the only ones I checked locally at the moment. std::mt19937_64 gen { }; @@ -230,7 +230,7 @@ void test() #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) - // These were the only ones I checked locally at the moment that use random tests. + // These were the only ones I checked locally at the moment. for (int npow = -8; npow < 8; ++npow) { @@ -339,6 +339,7 @@ int main() #ifdef TEST_MPF_50 test(); test(); + test_issue722(); #endif #ifdef TEST_MPFR_50 test(); @@ -351,6 +352,7 @@ int main() #ifdef TEST_CPP_DEC_FLOAT test(); test(); + test_issue722(); #ifndef SLOW_COMPLER // Some "peculiar" digit counts which stress our code: test > >(); @@ -372,6 +374,7 @@ int main() #ifdef TEST_CPP_BIN_FLOAT test(); test, long long> > >(); + test_issue722(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT test(); diff --git a/test/test_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index d8bb0ff8d..160b00b9b 100644 --- a/test/test_sf_import_c99.cpp +++ b/test/test_sf_import_c99.cpp @@ -2306,6 +2306,7 @@ int main() test_c99_appendix_F > > >(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT + test(); test(); test(); From a7731263bcc35ff401b9d8fd9b4cd648eb890192 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 12 Jul 2025 21:07:16 +0200 Subject: [PATCH 029/114] More docs improvements --- README.md | 5 +++- doc/tutorial.qbk | 3 ++ doc/tutorial_boost_rational.qbk | 50 --------------------------------- doc/tutorial_debug_adaptor.qbk | 8 +----- doc/tutorial_misc_backends.qbk | 1 - doc/tutorial_rational.qbk | 1 - 6 files changed, 8 insertions(+), 60 deletions(-) delete mode 100644 doc/tutorial_boost_rational.qbk diff --git a/README.md b/README.md index b1051d734..18db904a0 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ requiring extended range and precision. Multiprecision consists of a generic interface to the mathematics of large numbers as well as a selection of big number backends. -This includes interfaces to GMP, MPFR, MPIR and TomMath +These include interfaces to GMP, MPFR, MPIR and TomMath and also Multiprecision's own collection of Boost-licensed, header-only backends for integers, rationals, floats and complex-floats. @@ -42,6 +42,9 @@ This usually provides better performance than using types configured without exp The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/multiprecision/index.html). +A practical, comprehensive, instructive, clear and very helpful video regarding the use of Multiprecision +can be found [here](https://www.youtube.com/watch?v=mK4WjpvLj4c). + ## Using Multiprecision

diff --git a/doc/tutorial.qbk b/doc/tutorial.qbk index 9011dc25b..a9deff5a2 100644 --- a/doc/tutorial.qbk +++ b/doc/tutorial.qbk @@ -16,6 +16,9 @@ In order to use this library you need to make two choices: [link boost_multiprecision.tut.floats floating-point], [link boost_multiprecision.tut.rational rational], or [link boost_multiprecision.tut.complex complex]). * Which back-end do I want to perform the actual arithmetic (Boost-supplied, GMP, MPFR, MPC, Tommath etc)? +A practical, comprehensive, instructive, clear and very helpful video regarding the use of Multiprecision +can be found [@https://www.youtube.com/watch?v=mK4WjpvLj4c here]. + [include tutorial_integer.qbk] [include tutorial_floats.qbk] [include tutorial_interval_mpfi.qbk] diff --git a/doc/tutorial_boost_rational.qbk b/doc/tutorial_boost_rational.qbk deleted file mode 100644 index af54bc2b6..000000000 --- a/doc/tutorial_boost_rational.qbk +++ /dev/null @@ -1,50 +0,0 @@ -[/ - Copyright 2011 - 2020 John Maddock. - Copyright 2013 - 2019 Paul A. Bristow. - Copyright 2013 Christopher Kormanyos. - - 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). -] - -[section:tommath_rational tommath_rational] - -`#include ` - - namespace boost{ namespace multiprecision{ - - typedef rational_adpater tommath_rational; - typedef number tom_rational; - - }} // namespaces - -The `tommath_rational` back-end is used via the typedef `boost::multiprecision::tom_rational`. It acts as a thin wrapper around -`boost::rational` -to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision. - -The advantage of using this type rather than `boost::rational` directly, is that it is expression-template enabled, -greatly reducing the number of temporaries created in complex expressions. - -There are also non-member functions: - - tom_int numerator(const tom_rational&); - tom_int denominator(const tom_rational&); - -which return the numerator and denominator of the number. - -Things you should know when using this type: - -* Default constructed `tom_rational`s have the value zero (this the inherited Boost.Rational behavior). -* Division by zero results in a `std::overflow_error` being thrown. -* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be -interpreted as a valid rational number. -* No changes are made to [tommath]'s global state, so this type can safely coexist with other [tommath] code. -* Performance of this type has been found to be pretty poor - this need further investigation - but it appears that Boost.Rational -needs some improvement in this area. - -[h5 Example:] - -[mp_rat_eg] - -[endsect] [/section:tommath_rational tommath_rational] diff --git a/doc/tutorial_debug_adaptor.qbk b/doc/tutorial_debug_adaptor.qbk index c9114a6e9..55de94a30 100644 --- a/doc/tutorial_debug_adaptor.qbk +++ b/doc/tutorial_debug_adaptor.qbk @@ -32,13 +32,7 @@ multiprecision values can easily be inspected in the debugger by looking at the The down side of this approach is that runtimes are much slower when using this type. Set against that it can make debugging very much easier, certainly much easier than sprinkling code with `printf` statements. -When used in conjunction with the Visual C++ debugger visualisers, the value of a multiprecision type that uses this -backend is displayed in the debugger just a __fundamental value would be, here we're inspecting a value of type -`number > >`: - -[$../debugger1.png] - -Otherwise you will need to expand out the view and look at the "debug_value" member: +You will need to expand out the view and look at the "debug_value" member: [$../debugger2.png] diff --git a/doc/tutorial_misc_backends.qbk b/doc/tutorial_misc_backends.qbk index 827e02ab6..d4110fc6d 100644 --- a/doc/tutorial_misc_backends.qbk +++ b/doc/tutorial_misc_backends.qbk @@ -14,6 +14,5 @@ Backend types listed in this section are predominantly designed to aid debugging [include tutorial_logged_adaptor.qbk] [include tutorial_debug_adaptor.qbk] -[include tutorial_visualizers.qbk] [endsect] [/section:misc Miscellaneous Number Types.] diff --git a/doc/tutorial_rational.qbk b/doc/tutorial_rational.qbk index 2f592cad6..022b4571f 100644 --- a/doc/tutorial_rational.qbk +++ b/doc/tutorial_rational.qbk @@ -24,7 +24,6 @@ The following back-ends provide rational number arithmetic: [include tutorial_cpp_rational.qbk] [include tutorial_gmp_rational.qbk] [include tutorial_tommath_rational.qbk] -[include tutorial_boost_rational.qbk] [include tutorial_rational_adaptor.qbk] [endsect] [/section:rational Rational Number Types] From 50901d32104cc8b6bf18d5e6ab931de1ef5dd64a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 12 Jul 2025 21:17:17 +0200 Subject: [PATCH 030/114] Simplify complex examples --- example/cpp_complex_examples.cpp | 27 +++++++-------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/example/cpp_complex_examples.cpp b/example/cpp_complex_examples.cpp index 7d00cc738..0d807791a 100644 --- a/example/cpp_complex_examples.cpp +++ b/example/cpp_complex_examples.cpp @@ -1,5 +1,8 @@ /////////////////////////////////////////////////////////////// -// Copyright 2018 Nick Thompson. Distributed under the Boost +// Copyright 2018 - 2025 Nick Thompson. +// Copyright 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. +// Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt @@ -8,10 +11,11 @@ In the following, we will show how using MPC backend allows for the same operati */ //[cpp_complex_eg -#include -#include #include +#include +#include + template void complex_number_examples() { @@ -35,39 +39,22 @@ void complex_number_examples() std::cout << "Polar coordinates (phase !=0) : " << polar(r, theta) << std::endl; std::cout << "\nElementary special functions:\n"; - using std::exp; std::cout << "exp(z1) = " << exp(z1) << std::endl; - using std::log; std::cout << "log(z1) = " << log(z1) << std::endl; - using std::log10; std::cout << "log10(z1) = " << log10(z1) << std::endl; - using std::pow; std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl; - using std::sqrt; std::cout << "Take its square root : " << sqrt(z1) << std::endl; - using std::sin; std::cout << "sin(z1) = " << sin(z1) << std::endl; - using std::cos; std::cout << "cos(z1) = " << cos(z1) << std::endl; - using std::tan; std::cout << "tan(z1) = " << tan(z1) << std::endl; - using std::asin; std::cout << "asin(z1) = " << asin(z1) << std::endl; - using std::acos; std::cout << "acos(z1) = " << acos(z1) << std::endl; - using std::atan; std::cout << "atan(z1) = " << atan(z1) << std::endl; - using std::sinh; std::cout << "sinh(z1) = " << sinh(z1) << std::endl; - using std::cosh; std::cout << "cosh(z1) = " << cosh(z1) << std::endl; - using std::tanh; std::cout << "tanh(z1) = " << tanh(z1) << std::endl; - using std::asinh; std::cout << "asinh(z1) = " << asinh(z1) << std::endl; - using std::acosh; std::cout << "acosh(z1) = " << acosh(z1) << std::endl; - using std::atanh; std::cout << "atanh(z1) = " << atanh(z1) << std::endl; } From a1b13b4f91c2ae1dab8191f7c3197897533e3594 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 13 Jul 2025 13:43:10 +0200 Subject: [PATCH 031/114] More docs tuning --- doc/multiprecision.qbk | 2 +- doc/tutorial_float_eg.qbk | 6 +- example/cpp_complex_examples.cpp | 158 ++++++++++++++++++------------- 3 files changed, 95 insertions(+), 71 deletions(-) diff --git a/doc/multiprecision.qbk b/doc/multiprecision.qbk index cfe0344f9..90a39dd2c 100644 --- a/doc/multiprecision.qbk +++ b/doc/multiprecision.qbk @@ -132,7 +132,7 @@ [def __compiler_support [@https://en.cppreference.com/w/cpp/compiler_support compiler support]] [def __ULP [@http://en.wikipedia.org/wiki/Unit_in_the_last_place Unit in the last place (ULP)]] [def __Mathematica [@http://www.wolfram.com/products/mathematica/index.html Wolfram Mathematica]] -[def __WolframAlpha [@http://www.wolframalpha.com/ Wolfram Alpha]] +[def __WolframAlphaGLCoefs [@https://www.wolframalpha.com/input?i=Fit%5B%7B%7B21.0%2C+3.5%7D%2C+%7B51.0%2C+11.1%7D%2C+%7B101.0%2C+22.5%7D%2C+%7B201.0%2C+46.8%7D%7D%2C+%7B1%2C+d%2C+d%5E2%7D%2C+d%5D+FullSimplify%5B%25%5D Wolfram Alpha Gauss-Laguerre coefficients]] [def __Boost_Serialization [@https://www.boost.org/doc/libs/release/libs/serialization/doc/index.html Boost.Serialization]] [def __Boost_Math [@https://www.boost.org/doc/libs/release/libs/math/doc/index.html Boost.Math]] [def __Boost_Multiprecision [@https://www.boost.org/doc/libs/release/libs/multiprecision/doc/index.html Boost.Multiprecision]] diff --git a/doc/tutorial_float_eg.qbk b/doc/tutorial_float_eg.qbk index 5c4f42292..74c257e76 100644 --- a/doc/tutorial_float_eg.qbk +++ b/doc/tutorial_float_eg.qbk @@ -108,9 +108,9 @@ needed for convergence when using various counts of base-10 digits. Let's calibrate, for instance, the number of coefficients needed at the point `x = 1`. -Empirical data were used with __WolframAlpha : +Empirical data were used with __WolframAlphaGLCoefs : `` -Fit[{{21.0, 3.5}, {51.0, 11.1}, {101.0, 22.5}, {201.0, 46.8}}, {1, d, d^2}, d]FullSimplify[%] +Fit[{{21.0, 3.5}, {51.0, 11.1}, {101.0, 22.5}, {201.0, 46.8}}, {1, d, d^2}, d] FullSimplify[%] 0.0000178915 d^2 + 0.235487 d - 1.28301 or -1.28301 + (0.235487 + 0.0000178915 d) d @@ -127,7 +127,7 @@ followed by calculation of accurate abscissa and weights is: [gauss_laguerre_quadrature_output_1] Finally the result using Gauss-Laguerre quadrature is compared with a calculation using `cyl_bessel_k`, -and both are listed, finally confirming that none differ more than a small tolerance. +and both are listed, conclusively confirming that none differ by more than a small tolerance. [gauss_laguerre_quadrature_output_2] For more detail see comments in the source code for this example at [@../../example/gauss_laguerre_quadrature.cpp gauss_laguerre_quadrature.cpp]. diff --git a/example/cpp_complex_examples.cpp b/example/cpp_complex_examples.cpp index 0d807791a..e6c8d4d14 100644 --- a/example/cpp_complex_examples.cpp +++ b/example/cpp_complex_examples.cpp @@ -6,66 +6,90 @@ // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt -/*`This example demonstrates the usage of the MPC backend for multiprecision complex numbers. -In the following, we will show how using MPC backend allows for the same operations as the C++ standard library complex numbers. +/*`This example demonstrates the usage of the complex_adaptor backend for multiprecision complex numbers. +In the following, we will show how using the complex_adaptor backend together with number allows for the same operations as the C++ standard library complex numbers. */ //[cpp_complex_eg #include +#include #include #include -template +template +void elementary_functions(const NumericType z1) +{ + std::cout << "\nElementary special functions:\n"; + std::cout << "Absolute value : " << abs(z1) << std::endl; + using std::arg; + std::cout << "Argument : " << arg(z1) << std::endl; + using std::norm; + std::cout << "Norm : " << norm(z1) << std::endl; + using std::conj; + std::cout << "Complex conjugate : " << conj(z1) << std::endl; + using std::proj; + std::cout << "Proj on Riemann sphere : " << proj(z1) << std::endl; + std::cout << "exp(z1) : " << exp(z1) << std::endl; + std::cout << "log(z1) : " << log(z1) << std::endl; + std::cout << "log10(z1) : " << log10(z1) << std::endl; + std::cout << "pow(z1, z1) : " << pow(z1, z1) << std::endl; + std::cout << "Take its square root : " << sqrt(z1) << std::endl; + std::cout << "sin(z1) : " << sin(z1) << std::endl; + std::cout << "cos(z1) : " << cos(z1) << std::endl; + std::cout << "tan(z1) : " << tan(z1) << std::endl; + std::cout << "asin(z1) : " << asin(z1) << std::endl; + std::cout << "acos(z1) : " << acos(z1) << std::endl; + std::cout << "atan(z1) : " << atan(z1) << std::endl; + std::cout << "sinh(z1) : " << sinh(z1) << std::endl; + std::cout << "cosh(z1) : " << cosh(z1) << std::endl; + std::cout << "tanh(z1) : " << tanh(z1) << std::endl; + std::cout << "asinh(z1) : " << asinh(z1) << std::endl; + std::cout << "acosh(z1) : " << acosh(z1) << std::endl; + std::cout << "atanh(z1) : " << atanh(z1) << std::endl; +} + +template void complex_number_examples() { - Complex z1{0, 1}; - std::cout << std::setprecision(std::numeric_limits::digits10); - std::cout << std::scientific << std::fixed; - std::cout << "Print a complex number: " << z1 << std::endl; - std::cout << "Square it : " << z1*z1 << std::endl; - std::cout << "Real part : " << z1.real() << " = " << real(z1) << std::endl; - std::cout << "Imaginary part : " << z1.imag() << " = " << imag(z1) << std::endl; - using std::abs; - std::cout << "Absolute value : " << abs(z1) << std::endl; - std::cout << "Argument : " << arg(z1) << std::endl; - std::cout << "Norm : " << norm(z1) << std::endl; - std::cout << "Complex conjugate : " << conj(z1) << std::endl; - std::cout << "Projection onto Riemann sphere: " << proj(z1) << std::endl; - typename Complex::value_type r = 1; - typename Complex::value_type theta = 0.8; + using complex_type = ComplexType; + using real_type = typename complex_type::value_type; + + complex_type z1 { real_type(0), real_type(1) }; + + std::cout << "Print a complex number : " << z1 << std::endl; + std::cout << "Square it : " << z1*z1 << std::endl; + std::cout << "Real part : " << z1.real() << " = " << real(z1) << std::endl; + std::cout << "Imaginary part : " << z1.imag() << " = " << imag(z1) << std::endl; + + real_type r { 1 }; + real_type theta { 0.75 }; using std::polar; - std::cout << "Polar coordinates (phase = 0) : " << polar(r) << std::endl; - std::cout << "Polar coordinates (phase !=0) : " << polar(r, theta) << std::endl; + std::cout << "Polar coord phase = 0 : " << polar(r) << std::endl; + std::cout << "Polar coord phase != 0 : " << polar(r, theta) << std::endl; - std::cout << "\nElementary special functions:\n"; - std::cout << "exp(z1) = " << exp(z1) << std::endl; - std::cout << "log(z1) = " << log(z1) << std::endl; - std::cout << "log10(z1) = " << log10(z1) << std::endl; - std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl; - std::cout << "Take its square root : " << sqrt(z1) << std::endl; - std::cout << "sin(z1) = " << sin(z1) << std::endl; - std::cout << "cos(z1) = " << cos(z1) << std::endl; - std::cout << "tan(z1) = " << tan(z1) << std::endl; - std::cout << "asin(z1) = " << asin(z1) << std::endl; - std::cout << "acos(z1) = " << acos(z1) << std::endl; - std::cout << "atan(z1) = " << atan(z1) << std::endl; - std::cout << "sinh(z1) = " << sinh(z1) << std::endl; - std::cout << "cosh(z1) = " << cosh(z1) << std::endl; - std::cout << "tanh(z1) = " << tanh(z1) << std::endl; - std::cout << "asinh(z1) = " << asinh(z1) << std::endl; - std::cout << "acosh(z1) = " << acosh(z1) << std::endl; - std::cout << "atanh(z1) = " << atanh(z1) << std::endl; + elementary_functions(z1); } int main() { + const auto flags_orig = std::cout.flags(); + + std::cout << std::scientific << std::fixed; + std::cout << "First, some operations we usually perform with std::complex:\n"; + std::cout << std::setprecision(std::numeric_limits::value_type>::digits10); complex_number_examples>(); + std::cout << "\nNow the same operations performed using quad precision complex numbers:\n"; + std::cout << std::setprecision(std::numeric_limits::digits10); complex_number_examples(); - return 0; + std::cout << "\nNow the same elementary functions performed using built-in real-valued numbers:\n"; + std::cout << std::setprecision(std::numeric_limits::digits10); + elementary_functions(0.125F); + + std::cout.flags(flags_orig); } //] @@ -73,35 +97,35 @@ int main() //[cpp_complex_out -Print a complex number: (0.000000000000000000000000000000000,1.000000000000000000000000000000000) -Square it : -1.000000000000000000000000000000000 -Real part : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000 -Imaginary part : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000 -Absolute value : 1.000000000000000000000000000000000 -Argument : 1.570796326794896619231321691639751 -Norm : 1.000000000000000000000000000000000 -Complex conjugate : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000) -Projection onto Riemann sphere: (0.000000000000000000000000000000000,1.000000000000000000000000000000000) -Polar coordinates (phase = 0) : 1.000000000000000000000000000000000 -Polar coordinates (phase !=0) : (0.696706709347165389063740022772448,0.717356090899522792567167815703377) +Print a complex number : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) +Square it : -1.000000000000000000000000000000000 +Real part : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000 +Imaginary part : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000 +Polar coord phase = 0 : 1.000000000000000000000000000000000 +Polar coord phase != 0 : (0.731688868873820886311838753000085,0.681638760023334166733241952779894) Elementary special functions: -exp(z1) = (0.540302305868139717400936607442977,0.841470984807896506652502321630299) -log(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751) -log10(z1) = (0.000000000000000000000000000000000,0.682188176920920673742891812715678) -pow(z1, z1) = 0.207879576350761908546955619834979 -Take its square root : (0.707106781186547524400844362104849,0.707106781186547524400844362104849) -sin(z1) = (0.000000000000000000000000000000000,1.175201193643801456882381850595601) -cos(z1) = 1.543080634815243778477905620757062 -tan(z1) = (0.000000000000000000000000000000000,0.761594155955764888119458282604794) -asin(z1) = (0.000000000000000000000000000000000,0.881373587019543025232609324979793) -acos(z1) = (1.570796326794896619231321691639751,-0.881373587019543025232609324979793) -atan(z1) = (0.000000000000000000000000000000000,inf) -sinh(z1) = (0.000000000000000000000000000000000,0.841470984807896506652502321630299) -cosh(z1) = 0.540302305868139717400936607442977 -tanh(z1) = (0.000000000000000000000000000000000,1.557407724654902230506974807458360) -asinh(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751) -acosh(z1) = (0.881373587019543025232609324979792,1.570796326794896619231321691639751) -atanh(z1) = (0.000000000000000000000000000000000,0.785398163397448309615660845819876) +Absolute value : 1.000000000000000000000000000000000 +Argument : 1.570796326794896619231321691639751 +Norm : 1.000000000000000000000000000000000 +Complex conjugate : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000) +Proj on Riemann sphere : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) +exp(z1) : (0.540302305868139717400936607442977,0.841470984807896506652502321630299) +log(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) +log10(z1) : (0.000000000000000000000000000000000,0.682188176920920673742891812715678) +pow(z1, z1) : 0.207879576350761908546955619834979 +Take its square root : (0.707106781186547524400844362104849,0.707106781186547524400844362104849) +sin(z1) : (0.000000000000000000000000000000000,1.175201193643801456882381850595601) +cos(z1) : 1.543080634815243778477905620757062 +tan(z1) : (0.000000000000000000000000000000000,0.761594155955764888119458282604794) +asin(z1) : (0.000000000000000000000000000000000,0.881373587019543025232609324979792) +acos(z1) : (1.570796326794896619231321691639751,-0.881373587019543025232609324979792) +atan(z1) : (0.000000000000000000000000000000000,inf) +sinh(z1) : (0.000000000000000000000000000000000,0.841470984807896506652502321630299) +cosh(z1) : 0.540302305868139717400936607442977 +tanh(z1) : (0.000000000000000000000000000000000,1.557407724654902230506974807458360) +asinh(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) +acosh(z1) : (0.881373587019543025232609324979792,1.570796326794896619231321691639751) +atanh(z1) : (0.000000000000000000000000000000000,0.785398163397448309615660845819876) //] */ From 3305c6914eb8465c5fda64e4bba588ea55bf5a24 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 13 Jul 2025 15:36:05 +0200 Subject: [PATCH 032/114] Restore the proper using statements --- example/cpp_complex_examples.cpp | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/example/cpp_complex_examples.cpp b/example/cpp_complex_examples.cpp index e6c8d4d14..fef0dcb7c 100644 --- a/example/cpp_complex_examples.cpp +++ b/example/cpp_complex_examples.cpp @@ -30,22 +30,39 @@ void elementary_functions(const NumericType z1) std::cout << "Complex conjugate : " << conj(z1) << std::endl; using std::proj; std::cout << "Proj on Riemann sphere : " << proj(z1) << std::endl; + using std::exp; std::cout << "exp(z1) : " << exp(z1) << std::endl; + using std::log; std::cout << "log(z1) : " << log(z1) << std::endl; + using std::log10; std::cout << "log10(z1) : " << log10(z1) << std::endl; + using std::pow; std::cout << "pow(z1, z1) : " << pow(z1, z1) << std::endl; + using std::sqrt; std::cout << "Take its square root : " << sqrt(z1) << std::endl; + using std::sin; std::cout << "sin(z1) : " << sin(z1) << std::endl; + using std::cos; std::cout << "cos(z1) : " << cos(z1) << std::endl; + using std::tan; std::cout << "tan(z1) : " << tan(z1) << std::endl; + using std::asin; std::cout << "asin(z1) : " << asin(z1) << std::endl; + using std::acos; std::cout << "acos(z1) : " << acos(z1) << std::endl; + using std::atan; std::cout << "atan(z1) : " << atan(z1) << std::endl; + using std::sinh; std::cout << "sinh(z1) : " << sinh(z1) << std::endl; + using std::cosh; std::cout << "cosh(z1) : " << cosh(z1) << std::endl; + using std::tanh; std::cout << "tanh(z1) : " << tanh(z1) << std::endl; + using std::asinh; std::cout << "asinh(z1) : " << asinh(z1) << std::endl; + using std::acosh; std::cout << "acosh(z1) : " << acosh(z1) << std::endl; + using std::atanh; std::cout << "atanh(z1) : " << atanh(z1) << std::endl; } @@ -85,9 +102,10 @@ int main() std::cout << std::setprecision(std::numeric_limits::digits10); complex_number_examples(); - std::cout << "\nNow the same elementary functions performed using built-in real-valued numbers:\n"; - std::cout << std::setprecision(std::numeric_limits::digits10); - elementary_functions(0.125F); + std::cout << "\nNow the elementary functions performed using built-in, real-valued long double numbers:\n"; + std::cout << std::setprecision(std::numeric_limits::digits10); + const long double ld_arg { 0.125L }; + elementary_functions(ld_arg); std::cout.flags(flags_orig); } From 2ad2822bfd7c8bd7a8b55d68c9c168857dff6109 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 09:47:28 +0200 Subject: [PATCH 033/114] Tuning and simplification complex example --- example/cpp_complex_examples.cpp | 187 ++++++++++++------------------- 1 file changed, 72 insertions(+), 115 deletions(-) diff --git a/example/cpp_complex_examples.cpp b/example/cpp_complex_examples.cpp index fef0dcb7c..2e1166293 100644 --- a/example/cpp_complex_examples.cpp +++ b/example/cpp_complex_examples.cpp @@ -11,139 +11,96 @@ In the following, we will show how using the complex_adaptor backend together wi */ //[cpp_complex_eg -#include - -#include -#include #include +#include +#include -template -void elementary_functions(const NumericType z1) -{ - std::cout << "\nElementary special functions:\n"; - std::cout << "Absolute value : " << abs(z1) << std::endl; - using std::arg; - std::cout << "Argument : " << arg(z1) << std::endl; - using std::norm; - std::cout << "Norm : " << norm(z1) << std::endl; - using std::conj; - std::cout << "Complex conjugate : " << conj(z1) << std::endl; - using std::proj; - std::cout << "Proj on Riemann sphere : " << proj(z1) << std::endl; - using std::exp; - std::cout << "exp(z1) : " << exp(z1) << std::endl; - using std::log; - std::cout << "log(z1) : " << log(z1) << std::endl; - using std::log10; - std::cout << "log10(z1) : " << log10(z1) << std::endl; - using std::pow; - std::cout << "pow(z1, z1) : " << pow(z1, z1) << std::endl; - using std::sqrt; - std::cout << "Take its square root : " << sqrt(z1) << std::endl; - using std::sin; - std::cout << "sin(z1) : " << sin(z1) << std::endl; - using std::cos; - std::cout << "cos(z1) : " << cos(z1) << std::endl; - using std::tan; - std::cout << "tan(z1) : " << tan(z1) << std::endl; - using std::asin; - std::cout << "asin(z1) : " << asin(z1) << std::endl; - using std::acos; - std::cout << "acos(z1) : " << acos(z1) << std::endl; - using std::atan; - std::cout << "atan(z1) : " << atan(z1) << std::endl; - using std::sinh; - std::cout << "sinh(z1) : " << sinh(z1) << std::endl; - using std::cosh; - std::cout << "cosh(z1) : " << cosh(z1) << std::endl; - using std::tanh; - std::cout << "tanh(z1) : " << tanh(z1) << std::endl; - using std::asinh; - std::cout << "asinh(z1) : " << asinh(z1) << std::endl; - using std::acosh; - std::cout << "acosh(z1) : " << acosh(z1) << std::endl; - using std::atanh; - std::cout << "atanh(z1) : " << atanh(z1) << std::endl; -} - -template +template void complex_number_examples() { - using complex_type = ComplexType; - using real_type = typename complex_type::value_type; - - complex_type z1 { real_type(0), real_type(1) }; - - std::cout << "Print a complex number : " << z1 << std::endl; - std::cout << "Square it : " << z1*z1 << std::endl; - std::cout << "Real part : " << z1.real() << " = " << real(z1) << std::endl; - std::cout << "Imaginary part : " << z1.imag() << " = " << imag(z1) << std::endl; - - real_type r { 1 }; - real_type theta { 0.75 }; + Complex z1{0, 1}; + std::cout << std::setprecision(std::numeric_limits::digits10); + std::cout << std::scientific << std::fixed; + std::cout << "Print a complex number : " << z1 << std::endl; + std::cout << "Square it : " << z1*z1 << std::endl; + std::cout << "Real part : " << z1.real() << " = " << real(z1) << std::endl; + std::cout << "Imaginary part : " << z1.imag() << " = " << imag(z1) << std::endl; + std::cout << "Absolute value : " << abs(z1) << std::endl; + std::cout << "Argument : " << arg(z1) << std::endl; + std::cout << "Norm : " << norm(z1) << std::endl; + std::cout << "Complex conjugate : " << conj(z1) << std::endl; + std::cout << "Proj onto Riemann sphere : " << proj(z1) << std::endl; + typename Complex::value_type r = 1; + typename Complex::value_type theta = 0.8; + + // We need a using declaration here, since polar is called with a scalar: using std::polar; - std::cout << "Polar coord phase = 0 : " << polar(r) << std::endl; - std::cout << "Polar coord phase != 0 : " << polar(r, theta) << std::endl; - elementary_functions(z1); + std::cout << "Polar coord phase = 0 : " << polar(r) << std::endl; + std::cout << "Polar coord phase != 0 : " << polar(r, theta) << std::endl; + + std::cout << "\nElementary special functions:\n"; + std::cout << "exp(z1) : " << exp(z1) << std::endl; + std::cout << "log(z1) : " << log(z1) << std::endl; + std::cout << "log10(z1) : " << log10(z1) << std::endl; + std::cout << "pow(z1, z1) : " << pow(z1, z1) << std::endl; + std::cout << "Take its square root : " << sqrt(z1) << std::endl; + std::cout << "sin(z1) : " << sin(z1) << std::endl; + std::cout << "cos(z1) : " << cos(z1) << std::endl; + std::cout << "tan(z1) : " << tan(z1) << std::endl; + std::cout << "asin(z1) : " << asin(z1) << std::endl; + std::cout << "acos(z1) : " << acos(z1) << std::endl; + std::cout << "atan(z1) : " << atan(z1) << std::endl; + std::cout << "sinh(z1) : " << sinh(z1) << std::endl; + std::cout << "cosh(z1) : " << cosh(z1) << std::endl; + std::cout << "tanh(z1) : " << tanh(z1) << std::endl; + std::cout << "asinh(z1) : " << asinh(z1) << std::endl; + std::cout << "acosh(z1) : " << acosh(z1) << std::endl; + std::cout << "atanh(z1) : " << atanh(z1) << std::endl; } int main() { - const auto flags_orig = std::cout.flags(); - - std::cout << std::scientific << std::fixed; - - std::cout << "First, some operations we usually perform with std::complex:\n"; - std::cout << std::setprecision(std::numeric_limits::value_type>::digits10); + std::cout << "First, some operations performed with std::complex:\n"; complex_number_examples>(); - std::cout << "\nNow the same operations performed using quad precision complex numbers:\n"; - std::cout << std::setprecision(std::numeric_limits::digits10); + std::cout << "\nNow the same operations performed with quad precision complex numbers:\n"; complex_number_examples(); - - std::cout << "\nNow the elementary functions performed using built-in, real-valued long double numbers:\n"; - std::cout << std::setprecision(std::numeric_limits::digits10); - const long double ld_arg { 0.125L }; - elementary_functions(ld_arg); - - std::cout.flags(flags_orig); -} -//] +}//] /* //[cpp_complex_out - -Print a complex number : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) -Square it : -1.000000000000000000000000000000000 -Real part : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000 -Imaginary part : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000 -Polar coord phase = 0 : 1.000000000000000000000000000000000 -Polar coord phase != 0 : (0.731688868873820886311838753000085,0.681638760023334166733241952779894) +Now the same operations performed using quad precision complex numbers: +Print a complex number : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) +Square it : -1.000000000000000000000000000000000 +Real part : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000 +Imaginary part : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000 +Absolute value : 1.000000000000000000000000000000000 +Argument : 1.570796326794896619231321691639751 +Norm : 1.000000000000000000000000000000000 +Complex conjugate : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000) +Proj onto Riemann sphere : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) +Polar coord phase = 0 : 1.000000000000000000000000000000000 +Polar coord phase != 0 : (0.696706709347165389063740022772448,0.717356090899522792567167815703377) Elementary special functions: -Absolute value : 1.000000000000000000000000000000000 -Argument : 1.570796326794896619231321691639751 -Norm : 1.000000000000000000000000000000000 -Complex conjugate : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000) -Proj on Riemann sphere : (0.000000000000000000000000000000000,1.000000000000000000000000000000000) -exp(z1) : (0.540302305868139717400936607442977,0.841470984807896506652502321630299) -log(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) -log10(z1) : (0.000000000000000000000000000000000,0.682188176920920673742891812715678) -pow(z1, z1) : 0.207879576350761908546955619834979 -Take its square root : (0.707106781186547524400844362104849,0.707106781186547524400844362104849) -sin(z1) : (0.000000000000000000000000000000000,1.175201193643801456882381850595601) -cos(z1) : 1.543080634815243778477905620757062 -tan(z1) : (0.000000000000000000000000000000000,0.761594155955764888119458282604794) -asin(z1) : (0.000000000000000000000000000000000,0.881373587019543025232609324979792) -acos(z1) : (1.570796326794896619231321691639751,-0.881373587019543025232609324979792) -atan(z1) : (0.000000000000000000000000000000000,inf) -sinh(z1) : (0.000000000000000000000000000000000,0.841470984807896506652502321630299) -cosh(z1) : 0.540302305868139717400936607442977 -tanh(z1) : (0.000000000000000000000000000000000,1.557407724654902230506974807458360) -asinh(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) -acosh(z1) : (0.881373587019543025232609324979792,1.570796326794896619231321691639751) -atanh(z1) : (0.000000000000000000000000000000000,0.785398163397448309615660845819876) +exp(z1) : (0.540302305868139717400936607442977,0.841470984807896506652502321630299) +log(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) +log10(z1) : (0.000000000000000000000000000000000,0.682188176920920673742891812715678) +pow(z1, z1) : 0.207879576350761908546955619834979 +Take its square root : (0.707106781186547524400844362104849,0.707106781186547524400844362104849) +sin(z1) : (0.000000000000000000000000000000000,1.175201193643801456882381850595601) +cos(z1) : 1.543080634815243778477905620757062 +tan(z1) : (0.000000000000000000000000000000000,0.761594155955764888119458282604794) +asin(z1) : (0.000000000000000000000000000000000,0.881373587019543025232609324979792) +acos(z1) : (1.570796326794896619231321691639751,-0.881373587019543025232609324979792) +atan(z1) : (0.000000000000000000000000000000000,inf) +sinh(z1) : (0.000000000000000000000000000000000,0.841470984807896506652502321630299) +cosh(z1) : 0.540302305868139717400936607442977 +tanh(z1) : (0.000000000000000000000000000000000,1.557407724654902230506974807458360) +asinh(z1) : (0.000000000000000000000000000000000,1.570796326794896619231321691639751) +acosh(z1) : (0.881373587019543025232609324979792,1.570796326794896619231321691639751) +atanh(z1) : (0.000000000000000000000000000000000,0.785398163397448309615660845819876) //] */ From 1ac05b1832d7c71812ff841d4d1624fe8d511d07 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 13:03:39 +0200 Subject: [PATCH 034/114] Get complex_adaptor working for cpp_dec_float --- .../boost/multiprecision/cpp_dec_float.hpp | 72 +++++++- test/Jamfile.v2 | 2 +- test/test_complex.cpp | 126 +++++++------- test/test_complex_df.cpp | 160 ------------------ 4 files changed, 140 insertions(+), 220 deletions(-) delete mode 100644 test/test_complex_df.cpp diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index e5e6ee940..884ff9a54 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -3166,20 +3166,84 @@ inline void eval_add(cpp_dec_float& result, c result += o; } template +inline void eval_add(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) +{ + if (&result == &b) + { + const cpp_dec_float b_local(b); + + result = a; + result += b_local; + } + else + { + result = a; + result += b; + } +} +template inline void eval_subtract(cpp_dec_float& result, const cpp_dec_float& o) { result -= o; } template +inline void eval_subtract(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) +{ + if (&result == &b) + { + const cpp_dec_float b_local(b); + + result = a; + result -= b_local; + } + else + { + result = a; + result -= b; + } +} +template inline void eval_multiply(cpp_dec_float& result, const cpp_dec_float& o) { result *= o; } template +inline void eval_multiply(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) +{ + if (&result == &b) + { + const cpp_dec_float b_local(b); + + result = a; + result *= b_local; + } + else + { + result = a; + result *= b; + } +} +template inline void eval_divide(cpp_dec_float& result, const cpp_dec_float& o) { result /= o; } +template +inline void eval_divide(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) +{ + if (&result == &b) + { + const cpp_dec_float b_local(b); + + result = a; + result /= b_local; + } + else + { + result = a; + result /= b; + } +} template inline void eval_add(cpp_dec_float& result, const unsigned long long& o) @@ -3552,7 +3616,13 @@ inline bool eval_is_zero(const cpp_dec_float& template inline int eval_get_sign(const cpp_dec_float& val) { - return val.iszero() ? 0 : val.isneg() ? -1 : 1; + return (val.iszero() ? 0 : (val.isneg() ? -1 : 1)); +} + +template +inline int eval_signbit(const cpp_dec_float& val) +{ + return ((eval_get_sign(val) == -1) ? 1 : 0); } template diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 71463828a..9af721754 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -219,7 +219,7 @@ test-suite arithmetic_tests : [ run test_mpf_precisions.cpp gmp : : : [ check-target-builds ../config//has_gmp : : no ] ] [ run test_threaded_precision.cpp mpfr gmp : : : [ check-target-builds ../config//has_mpfr : : no ] TEST_MPF_50 : test_threaded_precision_mpf ] [ run test_complex.cpp : : : [ check-target-builds ../config//has_mpc : TEST_MPC mpc mpfr gmp ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_complex.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] TEST_CPP_DOUBLE_FLOAT : test_complex_df ] + [ run test_complex.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] TEST_CPP_DOUBLE_FLOAT : test_complex_cpp_double_fp ] [ run test_arithmetic_complex_adaptor.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_complex_adaptor_2.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_complex128.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] diff --git a/test/test_complex.cpp b/test/test_complex.cpp index b89ab45bb..d6bbdb7d5 100644 --- a/test/test_complex.cpp +++ b/test/test_complex.cpp @@ -12,8 +12,9 @@ #include #include -#include #include +#include +#include #ifdef TEST_MPC #include @@ -21,11 +22,6 @@ #ifdef BOOST_HAS_FLOAT128 #include #endif -#if 0 // Testing cpp_dec_float does not (yet) work. -#ifdef TEST_CPP_DEC_FLOAT -#include -#endif -#endif // Testing cpp_dec_float does not (yet) work. #ifdef TEST_CPP_DOUBLE_FLOAT #include #endif @@ -74,19 +70,23 @@ void test() { std::cout << "Testing type: " << typeid(complex_type).name() << std::endl; - using float_type = typename complex_type::value_type; + using real_type = typename complex_type::value_type; - const std::string str_tol("0." + std::string(std::size_t(std::numeric_limits::digits10 - 2), char('0')) + std::string(std::size_t(2U), char('9'))); + const std::string str_tol("0." + std::string(std::size_t(std::numeric_limits::digits10 - 2), char('0')) + std::string(std::size_t(2U), char('9'))); - const float_type tol = boost::lexical_cast(str_tol.c_str()); + const real_type tol = boost::lexical_cast(str_tol.c_str()); std::cout << "Testing with tolerance: " << tol << std::endl; - const complex_type z1(float_type(12U) / 10U, float_type(34U) / 10U); - const complex_type z2(float_type(56U) / 10U, float_type(78U) / 10U); - const complex_type i(float_type(0U), float_type(1U)); + const complex_type z1(real_type(12U) / 10U, real_type(34U) / 10U); + const complex_type z2(real_type(56U) / 10U, real_type(78U) / 10U); + const complex_type i(real_type(0U), real_type(1U)); - // See also, for example, numerical evaluation at Wolfram's Alpha. + // See also numerical evaluation at Wolfram Alpha. For instance, + // numerical evaluation of the sqrt() function is entered here: + // https://www.wolframalpha.com/input?i=N%5BSqrt%5B%2812%2F10%29+%2B+%28%2834+I%29%2F10%29%5D%2C+100%5D + // This corresponds to: + // N[Sqrt[(12/10) + ((34 I)/10)], 100] const complex_type result_01 = z1 / z2; // N[((12/10) + ((34 I)/10)) / ((56/10) + ((78 I)/10)), 100] const complex_type result_02 = complex_type(z1) /= z2; // Same as above. @@ -115,32 +115,32 @@ void test() const complex_type result_25 = log10(z1); const complex_type result_26 = tan(z1); - const complex_type control_01(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); - const complex_type control_02(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); - const complex_type control_03(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); - const complex_type control_04(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); - const complex_type control_05(boost::lexical_cast("+0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421"), boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800")); - const complex_type control_06(boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800"), boost::lexical_cast("-0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421")); - const complex_type control_07(boost::lexical_cast("+1.5500889128472581416161256546038815669761567486848749301860666965618993040312647033986371788677357208"), boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395")); - const complex_type control_08(boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395"), boost::lexical_cast("-1.550088912847258141616125654603881566976156748684874930186066696561899304031264703398637178867735721")); - const complex_type control_09(boost::lexical_cast("+13.97940880601799793712580492576613541257396172944193599059708688128463118206190268215536541838594224"), boost::lexical_cast("+5.42281547246340124509840716106599160358961329374827042575715571177243361237429170135167564889390308")); - const complex_type control_10(boost::lexical_cast("-1.459344510181031985739679928789446132188487461323488604725673812272622166868694452733557505015403343"), boost::lexical_cast("-0.462696919065088203665190427736980818788403809123239459086853242811288735966522197819049006036217659")); - const complex_type control_11(boost::lexical_cast("-1.750538529873144139045226521462954860931070703406867443705575327698120127693949444003491179539803540"), boost::lexical_cast("-0.385729418228941114585783287542904778761684113049496885765699906882071623161614865310950661528173196")); - const complex_type control_12(boost::lexical_cast("+1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744"), boost::lexical_cast("+1.231503712340851938048420309342408065643217837171236736591653326549432606404929552637127722999523972")); - const complex_type control_13(boost::lexical_cast("+0.327743052014525194927829972510958755346463574500092232271394201982853487105798907461836716106793827"), boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); - const complex_type control_14(boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707"), boost::lexical_cast("-1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); - const complex_type control_15(boost::lexical_cast("+1.472098546869956240046296809042356295374792147793626859728627826033391218153982606447668498652414512"), boost::lexical_cast("+0.265217990171315665670057272294610940896446740868740866767584213220467425714221740314551620202361000")); - const complex_type control_16(boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"), boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707")); - const complex_type control_17(boost::lexical_cast("+0.0865690591794584441708728351688739957204743888691393886743981396542994588169512931672375066385325971"), boost::lexical_cast("+1.3130218230654070842957152910299990808349983340931830855923498117237087784015805687823303378344863815")); - const complex_type control_18(boost::lexical_cast("-3.209883040054176124784906450252400993119558164730356048431249139970742294562643896737048684555206883"), boost::lexical_cast("-0.848426337294029318250973715279885597550087922172736344852553149693360359128137063129999667564390855")); - const complex_type control_19(boost::lexical_cast("+604.5331200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), boost::lexical_cast("-76.3721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")); - const complex_type control_20(boost::lexical_cast("-0.03277613870122620601990858385164868868755535963372013573012556184586155243067581560513902047571175876"), boost::lexical_cast("-0.08229096285844296094766104540456274850393339107196281307901532754610012233461478959682645571793968423")); - const complex_type control_21(boost::lexical_cast("+0.411234943477464115466545795217592784968613499972731227382657362718492707513495252941835813107553442"), boost::lexical_cast("+2.745341999926603737618437066482640101524732307796305942046035072295581269096378050886721641340275877")); - const complex_type control_22(boost::lexical_cast("+5.434908535625768828356755041961059164496984604872689362797531800548498933607521437636349622508613554091586385714"), boost::lexical_cast("-13.94830361398843812562310928749334812612948167559995042721295554487075295893311479161719058895913730856339351903")); - const complex_type control_23(boost::lexical_cast("1.960545624274756532757863147926614306606344023611895252748744677291286163242757958621205801565261867742512464966"), boost::lexical_cast("1.218868916639890129907167289780557894460959308403278313426586722860313100564201336738382323265397208095855244598")); - const complex_type control_24(boost::lexical_cast("0.850596957549373767077286649475619401136709177565015571227494818854489310955671601843121766190907188858336389856"), boost::lexical_cast("0.0768887100657045933256083080177585250084258780189064853743639639730289473609169028321092839605973770873615254969")); - const complex_type control_25(boost::lexical_cast("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), boost::lexical_cast("0.534835266713001566463607491752731752251883431441322590506193641481222966948925488019132991641807563958917938106")); - const complex_type control_26(boost::lexical_cast("0.001507101875805783093387404217890750536099188330196632424994845319829605048223792684300657269522163036773069001022"), boost::lexical_cast("1.001642796989141044331404504473463720289288872859072985897399123485040632782581390249339681901758734269277005380")); + const complex_type control_01(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); + const complex_type control_02(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); + const complex_type control_03(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); + const complex_type control_04(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); + const complex_type control_05(boost::lexical_cast("+0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421"), boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800")); + const complex_type control_06(boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800"), boost::lexical_cast("-0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421")); + const complex_type control_07(boost::lexical_cast("+1.5500889128472581416161256546038815669761567486848749301860666965618993040312647033986371788677357208"), boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395")); + const complex_type control_08(boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395"), boost::lexical_cast("-1.550088912847258141616125654603881566976156748684874930186066696561899304031264703398637178867735721")); + const complex_type control_09(boost::lexical_cast("+13.97940880601799793712580492576613541257396172944193599059708688128463118206190268215536541838594224"), boost::lexical_cast("+5.42281547246340124509840716106599160358961329374827042575715571177243361237429170135167564889390308")); + const complex_type control_10(boost::lexical_cast("-1.459344510181031985739679928789446132188487461323488604725673812272622166868694452733557505015403343"), boost::lexical_cast("-0.462696919065088203665190427736980818788403809123239459086853242811288735966522197819049006036217659")); + const complex_type control_11(boost::lexical_cast("-1.750538529873144139045226521462954860931070703406867443705575327698120127693949444003491179539803540"), boost::lexical_cast("-0.385729418228941114585783287542904778761684113049496885765699906882071623161614865310950661528173196")); + const complex_type control_12(boost::lexical_cast("+1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744"), boost::lexical_cast("+1.231503712340851938048420309342408065643217837171236736591653326549432606404929552637127722999523972")); + const complex_type control_13(boost::lexical_cast("+0.327743052014525194927829972510958755346463574500092232271394201982853487105798907461836716106793827"), boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); + const complex_type control_14(boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707"), boost::lexical_cast("-1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); + const complex_type control_15(boost::lexical_cast("+1.472098546869956240046296809042356295374792147793626859728627826033391218153982606447668498652414512"), boost::lexical_cast("+0.265217990171315665670057272294610940896446740868740866767584213220467425714221740314551620202361000")); + const complex_type control_16(boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"), boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707")); + const complex_type control_17(boost::lexical_cast("+0.0865690591794584441708728351688739957204743888691393886743981396542994588169512931672375066385325971"), boost::lexical_cast("+1.3130218230654070842957152910299990808349983340931830855923498117237087784015805687823303378344863815")); + const complex_type control_18(boost::lexical_cast("-3.209883040054176124784906450252400993119558164730356048431249139970742294562643896737048684555206883"), boost::lexical_cast("-0.848426337294029318250973715279885597550087922172736344852553149693360359128137063129999667564390855")); + const complex_type control_19(boost::lexical_cast("+604.5331200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), boost::lexical_cast("-76.3721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")); + const complex_type control_20(boost::lexical_cast("-0.03277613870122620601990858385164868868755535963372013573012556184586155243067581560513902047571175876"), boost::lexical_cast("-0.08229096285844296094766104540456274850393339107196281307901532754610012233461478959682645571793968423")); + const complex_type control_21(boost::lexical_cast("+0.411234943477464115466545795217592784968613499972731227382657362718492707513495252941835813107553442"), boost::lexical_cast("+2.745341999926603737618437066482640101524732307796305942046035072295581269096378050886721641340275877")); + const complex_type control_22(boost::lexical_cast("+5.434908535625768828356755041961059164496984604872689362797531800548498933607521437636349622508613554091586385714"), boost::lexical_cast("-13.94830361398843812562310928749334812612948167559995042721295554487075295893311479161719058895913730856339351903")); + const complex_type control_23(boost::lexical_cast("1.960545624274756532757863147926614306606344023611895252748744677291286163242757958621205801565261867742512464966"), boost::lexical_cast("1.218868916639890129907167289780557894460959308403278313426586722860313100564201336738382323265397208095855244598")); + const complex_type control_24(boost::lexical_cast("0.850596957549373767077286649475619401136709177565015571227494818854489310955671601843121766190907188858336389856"), boost::lexical_cast("0.0768887100657045933256083080177585250084258780189064853743639639730289473609169028321092839605973770873615254969")); + const complex_type control_25(boost::lexical_cast("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), boost::lexical_cast("0.534835266713001566463607491752731752251883431441322590506193641481222966948925488019132991641807563958917938106")); + const complex_type control_26(boost::lexical_cast("0.001507101875805783093387404217890750536099188330196632424994845319829605048223792684300657269522163036773069001022"), boost::lexical_cast("1.001642796989141044331404504473463720289288872859072985897399123485040632782581390249339681901758734269277005380")); BOOST_CHECK_CLOSE_FRACTION(result_01.real(), control_01.real(), tol); BOOST_CHECK_CLOSE_FRACTION(result_01.imag(), control_01.imag(), tol); @@ -195,7 +195,7 @@ void test() BOOST_CHECK_CLOSE_FRACTION(result_26.real(), control_26.real(), tol); BOOST_CHECK_CLOSE_FRACTION(result_26.imag(), control_26.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(abs(z1), boost::lexical_cast("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), tol) + BOOST_CHECK_CLOSE_FRACTION(abs(z1), boost::lexical_cast("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), tol) { std::mt19937_64 gen { time_point() }; @@ -207,19 +207,19 @@ void test() static_cast(1.5E10F) }; - float_type around_three_base("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"); + real_type around_three_base("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"); for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) { static_cast(index); - const float_type real_val = around_three_base * dis(gen); + const real_type real_val = around_three_base * dis(gen); const complex_type cpx(real_val); { const complex_type sqrt_cpx = sqrt(cpx); - const float_type sqrt_ctrl = sqrt(real_val); + const real_type sqrt_ctrl = sqrt(real_val); BOOST_CHECK_CLOSE_FRACTION(sqrt_cpx.real(), sqrt_ctrl, tol); BOOST_TEST((boost::multiprecision::fpclassify)(sqrt_cpx.imag()) == FP_ZERO); @@ -227,7 +227,7 @@ void test() { const complex_type exp_cpx = exp(cpx); - const float_type exp_ctrl = exp(real_val); + const real_type exp_ctrl = exp(real_val); BOOST_CHECK_CLOSE_FRACTION(exp_cpx.real(), exp_ctrl, tol); BOOST_TEST((boost::multiprecision::fpclassify)(exp_cpx.imag()) == FP_ZERO); @@ -240,7 +240,7 @@ void test() const complex_type cpx(around_three_base * dis(gen), around_three_base * dis(gen)); - const complex_type cpx_zero(::my_zero() * dis(gen), ::my_zero() * dis(gen)); + const complex_type cpx_zero(::my_zero() * dis(gen), ::my_zero() * dis(gen)); const complex_type cpx_result = pow(cpx, cpx_zero); const bool result_pow_zero_is_ok @@ -271,30 +271,40 @@ int main() local::test(); local::test(); #endif - local::test >, boost::multiprecision::et_on> >(); - local::test >, boost::multiprecision::et_off> >(); #ifdef BOOST_HAS_FLOAT128 local::test(); #endif -#if 0 // Testing cpp_dec_float does not (yet) work. -#ifdef TEST_CPP_DEC_FLOAT + { + using bin_float_backend_type = boost::multiprecision::cpp_bin_float<50>; + + using bin_float_complex_et_off_type = boost::multiprecision::number, boost::multiprecision::et_off>; + using bin_float_complex_et_on_type = boost::multiprecision::number, boost::multiprecision::et_on>; + + local::test(); + local::test(); + } + { using dec_float_backend_type = boost::multiprecision::cpp_dec_float<50>; - using dec_float_type = boost::multiprecision::number; + using dec_float_complex_et_off_type = boost::multiprecision::number, boost::multiprecision::et_off>; + using dec_float_complex_et_on_type = boost::multiprecision::number, boost::multiprecision::et_on>; - local::test(); + local::test(); + local::test(); } -#endif -#endif // Testing cpp_dec_float does not (yet) work. -#if defined(TEST_CPP_DOUBLE_FLOAT) +#ifdef TEST_CPP_DOUBLE_FLOAT { - local::test>, boost::multiprecision::et_off>>(); - local::test>, boost::multiprecision::et_off>>(); + using cpp_double_double_complex_type = boost::multiprecision::number>, boost::multiprecision::et_off>; + using cpp_double_long_double_complex_type = boost::multiprecision::number>, boost::multiprecision::et_off>; + + local::test(); + local::test(); #if defined(BOOST_HAS_FLOAT128) - local::test>, boost::multiprecision::et_off>>(); + using cpp_double_float128_complex_type = boost::multiprecision::number>, boost::multiprecision::et_off>; + local::test(); #endif } #endif @@ -302,4 +312,4 @@ int main() return boost::report_errors(); } -template auto my_zero() noexcept -> FloatType& { using float_type = FloatType; static float_type val_zero { 0 }; return val_zero; } +template auto my_zero() noexcept -> FloatType& { using real_type = FloatType; static real_type val_zero { 0 }; return val_zero; } diff --git a/test/test_complex_df.cpp b/test/test_complex_df.cpp deleted file mode 100644 index 4e5fab9e9..000000000 --- a/test/test_complex_df.cpp +++ /dev/null @@ -1,160 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// Copyright John Maddock 2016. -// Copyright Christopher Kormanyos 2016 - 2025. -// 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) -// - -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "test.hpp" - -namespace local { -template -void test() -{ - - typedef typename complex_type::value_type float_type; - - const std::string str_tol("0." + std::string(std::size_t(std::numeric_limits::digits10 - 2), char('0')) + std::string(std::size_t(2U), char('9'))); - - const float_type tol = boost::lexical_cast(str_tol.c_str()); - - std::cout << "Testing with tolerance: " << tol << std::endl; - - const complex_type z1(float_type(12U) / 10U, float_type(34U) / 10U); - const complex_type z2(float_type(56U) / 10U, float_type(78U) / 10U); - const complex_type i(float_type(0U), float_type(1U)); - - // See also, for example, numerical evaluation at Wolfram's Alpha. - - const complex_type result_01 = z1 / z2; // N[((12/10) + ((34 I)/10)) / ((56/10) + ((78 I)/10)), 100] - const complex_type result_02 = complex_type(z1) /= z2; // Same as above. - const complex_type result_03 = z1 / (i * z2); // N[((12/10) + ((34 I)/10)) / ((-78/10) + ((56 I)/10)), 100] - const complex_type result_04 = complex_type(z1) /= (i * z2); // Same as above. - const complex_type result_05 = z1.real() / z2; // N[((12/10) / ((56/10) + ((78 I)/10)), 100] - const complex_type result_06 = z1.real() / (i * z2); // N[((12/10) / ((-78/10) + ((56 I)/10)), 100] - const complex_type result_07 = sqrt(z1); // N[Sqrt[(12/10) + ((34 I)/10)], 100] - const complex_type result_08 = sqrt(-z1); // N[Sqrt[(-12/10) - ((34 I)/10)], 100] - const complex_type result_09 = sin(z1); // N[Sin[(12/10) + ((34 I)/10)], 100] - const complex_type result_10 = sinh(z1); // N[Sinh[(12/10) + ((34 I)/10)], 100] - const complex_type result_11 = cosh(z1); // N[Cosh[(12/10) + ((34 I)/10)], 100] - const complex_type result_12 = log(z1); // N[Log[(12/10) + ((34 I)/10)], 100] - const complex_type result_13 = asin(z1); // N[ArcSin[(12/10) + ((34 I)/10)], 100] - const complex_type result_14 = acos(z1); // N[ArcCos[(12/10) + ((34 I)/10)], 100] - const complex_type result_15 = atan(z1); // N[ArcTan[(12/10) + ((34 I)/10)], 100] - const complex_type result_16 = acosh(z1); // N[ArcCosh[(12/10) + ((34 I)/10)], 100] - const complex_type result_17 = atanh(z1); // N[ArcTanh[(12/10) + ((34 I)/10)], 100] - const complex_type result_18 = exp(z1); // N[Exp[(12/10) + ((34 I)/10)], 100] - const complex_type result_19 = pow(z1, 5); // N[((12/10) + ((34 I)/10)) ^ 5, 100] - const complex_type result_20 = pow(z1, z2); // N[((12/10) + ((34 I)/10)) ^ ((56/10) + ((78 I)/10)), 100] - const complex_type result_21 = pow(z1.real(), z2); // N[(12/10)^((56/10) + ((78 I)/10)), 100] - const complex_type result_22 = cos(z1); - const complex_type result_23 = asinh(z1); - const complex_type result_24 = tanh(z1); - const complex_type result_25 = log10(z1); - const complex_type result_26 = tan(z1); - - const complex_type control_01(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); - const complex_type control_02(boost::lexical_cast("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306")); - const complex_type control_03(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); - const complex_type control_04(boost::lexical_cast("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319")); - const complex_type control_05(boost::lexical_cast("+0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421"), boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800")); - const complex_type control_06(boost::lexical_cast("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800"), boost::lexical_cast("-0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421")); - const complex_type control_07(boost::lexical_cast("+1.5500889128472581416161256546038815669761567486848749301860666965618993040312647033986371788677357208"), boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395")); - const complex_type control_08(boost::lexical_cast("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395"), boost::lexical_cast("-1.550088912847258141616125654603881566976156748684874930186066696561899304031264703398637178867735721")); - const complex_type control_09(boost::lexical_cast("+13.97940880601799793712580492576613541257396172944193599059708688128463118206190268215536541838594224"), boost::lexical_cast("+5.42281547246340124509840716106599160358961329374827042575715571177243361237429170135167564889390308")); - const complex_type control_10(boost::lexical_cast("-1.459344510181031985739679928789446132188487461323488604725673812272622166868694452733557505015403343"), boost::lexical_cast("-0.462696919065088203665190427736980818788403809123239459086853242811288735966522197819049006036217659")); - const complex_type control_11(boost::lexical_cast("-1.750538529873144139045226521462954860931070703406867443705575327698120127693949444003491179539803540"), boost::lexical_cast("-0.385729418228941114585783287542904778761684113049496885765699906882071623161614865310950661528173196")); - const complex_type control_12(boost::lexical_cast("+1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744"), boost::lexical_cast("+1.231503712340851938048420309342408065643217837171236736591653326549432606404929552637127722999523972")); - const complex_type control_13(boost::lexical_cast("+0.327743052014525194927829972510958755346463574500092232271394201982853487105798907461836716106793827"), boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); - const complex_type control_14(boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707"), boost::lexical_cast("-1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795")); - const complex_type control_15(boost::lexical_cast("+1.472098546869956240046296809042356295374792147793626859728627826033391218153982606447668498652414512"), boost::lexical_cast("+0.265217990171315665670057272294610940896446740868740866767584213220467425714221740314551620202361000")); - const complex_type control_16(boost::lexical_cast("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"), boost::lexical_cast("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707")); - const complex_type control_17(boost::lexical_cast("+0.0865690591794584441708728351688739957204743888691393886743981396542994588169512931672375066385325971"), boost::lexical_cast("+1.3130218230654070842957152910299990808349983340931830855923498117237087784015805687823303378344863815")); - const complex_type control_18(boost::lexical_cast("-3.209883040054176124784906450252400993119558164730356048431249139970742294562643896737048684555206883"), boost::lexical_cast("-0.848426337294029318250973715279885597550087922172736344852553149693360359128137063129999667564390855")); - const complex_type control_19(boost::lexical_cast("+604.5331200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), boost::lexical_cast("-76.3721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")); - const complex_type control_20(boost::lexical_cast("-0.03277613870122620601990858385164868868755535963372013573012556184586155243067581560513902047571175876"), boost::lexical_cast("-0.08229096285844296094766104540456274850393339107196281307901532754610012233461478959682645571793968423")); - const complex_type control_21(boost::lexical_cast("+0.411234943477464115466545795217592784968613499972731227382657362718492707513495252941835813107553442"), boost::lexical_cast("+2.745341999926603737618437066482640101524732307796305942046035072295581269096378050886721641340275877")); - const complex_type control_22(boost::lexical_cast("+5.434908535625768828356755041961059164496984604872689362797531800548498933607521437636349622508613554091586385714"), boost::lexical_cast("-13.94830361398843812562310928749334812612948167559995042721295554487075295893311479161719058895913730856339351903")); - const complex_type control_23(boost::lexical_cast("1.960545624274756532757863147926614306606344023611895252748744677291286163242757958621205801565261867742512464966"), boost::lexical_cast("1.218868916639890129907167289780557894460959308403278313426586722860313100564201336738382323265397208095855244598")); - const complex_type control_24(boost::lexical_cast("0.850596957549373767077286649475619401136709177565015571227494818854489310955671601843121766190907188858336389856"), boost::lexical_cast("0.0768887100657045933256083080177585250084258780189064853743639639730289473609169028321092839605973770873615254969")); - const complex_type control_25(boost::lexical_cast("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), boost::lexical_cast("0.534835266713001566463607491752731752251883431441322590506193641481222966948925488019132991641807563958917938106")); - const complex_type control_26(boost::lexical_cast("0.001507101875805783093387404217890750536099188330196632424994845319829605048223792684300657269522163036773069001022"), boost::lexical_cast("1.001642796989141044331404504473463720289288872859072985897399123485040632782581390249339681901758734269277005380")); - - BOOST_CHECK_CLOSE_FRACTION(result_01.real(), control_01.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_01.imag(), control_01.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_02.real(), control_02.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_02.imag(), control_02.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_03.real(), control_03.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_03.imag(), control_03.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_04.real(), control_04.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_04.imag(), control_04.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_05.real(), control_05.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_05.imag(), control_05.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_06.real(), control_06.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_06.imag(), control_06.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_07.real(), control_07.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_07.imag(), control_07.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_08.real(), control_08.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_08.imag(), control_08.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_09.real(), control_09.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_09.imag(), control_09.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_10.real(), control_10.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_10.imag(), control_10.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_11.real(), control_11.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_11.imag(), control_11.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_12.real(), control_12.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_12.imag(), control_12.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_13.real(), control_13.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_13.imag(), control_13.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_14.real(), control_14.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_14.imag(), control_14.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_15.real(), control_15.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_15.imag(), control_15.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_16.real(), control_16.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_16.imag(), control_16.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_17.real(), control_17.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_17.imag(), control_17.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_18.real(), control_18.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_18.imag(), control_18.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_19.real(), control_19.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_19.imag(), control_19.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_20.real(), control_20.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_20.imag(), control_20.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_21.real(), control_21.real(), tol * 5); - BOOST_CHECK_CLOSE_FRACTION(result_21.imag(), control_21.imag(), tol * 5); - BOOST_CHECK_CLOSE_FRACTION(result_22.real(), control_22.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_22.imag(), control_22.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_23.real(), control_23.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_23.imag(), control_23.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_24.real(), control_24.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_24.imag(), control_24.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_25.real(), control_25.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_25.imag(), control_25.imag(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_26.real(), control_26.real(), tol); - BOOST_CHECK_CLOSE_FRACTION(result_26.imag(), control_26.imag(), tol); - - BOOST_CHECK_CLOSE_FRACTION(abs(z1), boost::lexical_cast("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), tol) -} -} // namespace local - -int main() -{ - local::test>, boost::multiprecision::et_off> >(); - local::test>, boost::multiprecision::et_off> >(); -#if defined(BOOST_HAS_FLOAT128) - using boost::multiprecision::float128_type; - local::test>, boost::multiprecision::et_off> >(); -#endif - return boost::report_errors(); -} From daaea2952d230b796f320fa8b598aabaffdbc649 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 16:35:27 +0200 Subject: [PATCH 035/114] Remove redundant and thus uncovered lines --- .../boost/multiprecision/detail/functions/pow.hpp | 3 --- test/test_pow.cpp | 12 ++++++++++++ 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 7ecee5db2..593ed227b 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -518,9 +518,6 @@ inline void eval_pow(T& result, const T& x, const T& a) case FP_ZERO: switch (fpc_a) { - case FP_ZERO: - result = si_type(1); - break; case FP_NAN: result = a; break; diff --git a/test/test_pow.cpp b/test/test_pow.cpp index 56f6d0d07..8c8387334 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -159,6 +159,18 @@ void test_issue722() BOOST_CHECK((boost::multiprecision::isnan)(pow_neg_inf_to_the_nan)); } + + for (int index = 0; index < 8; ++index) + { + static_cast(index); + + const T val_x_zero { ::my_zero() * dist(gen) }; + const T val_a_zero { ::my_zero() * dist(gen) }; + + const T pow_zero_to_the_zero = pow(val_x_zero, val_a_zero); + + BOOST_CHECK(pow_zero_to_the_zero == 1); + } } } From 5465bdddf06b5af32d41fd7bcc86ea8e7fd0285b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 18:46:39 +0200 Subject: [PATCH 036/114] Streamline one of the eval_pow overloads --- .../multiprecision/detail/functions/pow.hpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 593ed227b..660c9a919 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -488,8 +488,6 @@ template inline void eval_pow(T& result, const T& x, const T& a) { static_assert(number_category::value == number_kind_floating_point, "The pow function is only valid for floating point types."); - using si_type = typename boost::multiprecision::detail::canonical::type; - using fp_type = typename std::tuple_element<0, typename T::float_types>::type ; if ((&result == &x) || (&result == &a)) { @@ -499,21 +497,25 @@ inline void eval_pow(T& result, const T& x, const T& a) return; } + using si_type = typename boost::multiprecision::detail::canonical::type; + using fp_type = typename std::tuple_element<0, typename T::float_types>::type; + if ((a.compare(si_type(1)) == 0) || (x.compare(si_type(1)) == 0)) { result = x; return; } - if (a.compare(si_type(0)) == 0) + + const int fpc_x { eval_fpclassify(x) }; + const int fpc_a { eval_fpclassify(a) }; + + if (fpc_a == FP_ZERO) { result = si_type(1); return; } - int type = eval_fpclassify(x); - int fpc_a = eval_fpclassify(a); - - switch (type) + switch (fpc_x) { case FP_ZERO: switch (fpc_a) @@ -657,7 +659,7 @@ inline void eval_pow(T& result, const T& x, const T& a) result = si_type(0); } } - else if (type == FP_INFINITE) + else if (fpc_x == FP_INFINITE) { BOOST_IF_CONSTEXPR (std::numeric_limits >::has_quiet_NaN) { From 0be16898fdd6d68f37f030c319b74f0858d0d224 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 20:06:43 +0200 Subject: [PATCH 037/114] Keep tuning coverage --- test/test_complex.cpp | 4 ++ test/test_cpp_int_karatsuba.cpp | 10 +++++ test/test_pow.cpp | 11 ++++-- test/test_round.cpp | 66 ++++++++++++++++----------------- 4 files changed, 54 insertions(+), 37 deletions(-) diff --git a/test/test_complex.cpp b/test/test_complex.cpp index d6bbdb7d5..1d045ecd7 100644 --- a/test/test_complex.cpp +++ b/test/test_complex.cpp @@ -9,6 +9,10 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 +#ifdef _MSC_VER +#define _SCL_SECURE_NO_WARNINGS +#endif + #include #include diff --git a/test/test_cpp_int_karatsuba.cpp b/test/test_cpp_int_karatsuba.cpp index fb8df69d6..4c7fcffc9 100644 --- a/test/test_cpp_int_karatsuba.cpp +++ b/test/test_cpp_int_karatsuba.cpp @@ -102,6 +102,7 @@ typename std::enable_if +#include +#include #include #include @@ -38,8 +40,6 @@ #endif #include // Note: include this AFTER the test-backends are defined -#include -#include #if defined(TEST_MPF_50) #include @@ -130,8 +130,11 @@ namespace local { #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) // These were the only ones I checked locally at the moment. -// TEST_MPF_50 is included because it does its has_quiet_NaN is false. -// And this helps verify the constexpr logic of test_issue722(). + +// TEST_MPF_50 is included (even though it won't be tested) +// because its value of has_quiet_NaN is false. This has been +// done intentionally. Its inclusion here is intended to verify +// the constexpr logic implemented in test_issue722(). template void test_issue722() diff --git a/test/test_round.cpp b/test/test_round.cpp index 56ee5a255..c57bd4d8a 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -98,15 +98,15 @@ typename std::enable_if::value>::t if (fabs(a - u) > 0.5f) { - BOOST_ERROR("Rounded result differed by more than 0.5 from the original"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result differed by more than 0.5 from the original"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } if ((fabs(a - u) == 0.5f) && (fabs(static_cast(u)) < fabs(a))) { - BOOST_ERROR("Rounded result was towards zero with boost::round"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result was towards zero with boost::round"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } } template @@ -115,15 +115,15 @@ typename std::enable_if::value>::ty BOOST_MATH_STD_USING if (upper(T(fabs(a - u))) > 0.5f) { - BOOST_ERROR("Rounded result differed by more than 0.5 from the original"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result differed by more than 0.5 from the original"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } if ((upper(T(fabs(a - u))) == 0.5f) && (fabs(static_cast(u)) < fabs(a))) { - BOOST_ERROR("Rounded result was towards zero with boost::round"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result was towards zero with boost::round"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } } @@ -155,23 +155,23 @@ void check_trunc_result(T a, U u) if (fabs(a - u) >= 1) { - BOOST_ERROR("Rounded result differed by more than 1 from the original"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result differed by more than 1 from the original"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } if (abs(a) < safe_abs(u)) { - BOOST_ERROR("Truncated result had larger absolute value than the original"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << abs(a) << safe_abs(u) << std::endl; + BOOST_ERROR("Truncated result had larger absolute value than the original"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << abs(a) << safe_abs(u) << std::endl; // LCOV_EXCL_LINE } if (fabs(static_cast(u)) > fabs(a)) { - BOOST_ERROR("Rounded result was away from zero with boost::trunc"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << u << std::endl; + BOOST_ERROR("Rounded result was away from zero with boost::trunc"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << u << std::endl; // LCOV_EXCL_LINE } } @@ -203,28 +203,28 @@ void check_modf_result(T a, T fract, U ipart) if (local::modf_fail_gate(sum, a)) { - BOOST_ERROR("Fractional and integer results do not add up to the original value"); - std::cerr << "Values were: " << std::setprecision(35) << " " - << std::left << a << ipart << " " << fract << std::endl; + BOOST_ERROR("Fractional and integer results do not add up to the original value"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << " " // LCOV_EXCL_LINE + << std::left << a << ipart << " " << fract << std::endl; // LCOV_EXCL_LINE } if ((boost::math::sign(a) != boost::math::sign(fract)) && boost::math::sign(fract)) { - BOOST_ERROR("Original and fractional parts have differing signs"); - std::cerr << "Values were: " << std::setprecision(35) << " " - << std::left << a << ipart << " " << fract << std::endl; + BOOST_ERROR("Original and fractional parts have differing signs"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << " " // LCOV_EXCL_LINE + << std::left << a << ipart << " " << fract << std::endl; // LCOV_EXCL_LINE } if ((boost::math::sign(a) != boost::math::sign(ipart)) && boost::math::sign(ipart)) { - BOOST_ERROR("Original and integer parts have differing signs"); - std::cerr << "Values were: " << std::setprecision(35) << " " - << std::left << a << ipart << " " << ipart << std::endl; + BOOST_ERROR("Original and integer parts have differing signs"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << " " // LCOV_EXCL_LINE + << std::left << a << ipart << " " << ipart << std::endl; // LCOV_EXCL_LINE } if (fabs(a - ipart) >= 1) { - BOOST_ERROR("Rounded result differed by more than 1 from the original"); - std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) - << std::left << a << ipart << std::endl; + BOOST_ERROR("Rounded result differed by more than 1 from the original"); // LCOV_EXCL_LINE + std::cerr << "Values were: " << std::setprecision(35) << std::setw(40) // LCOV_EXCL_LINE + << std::left << a << ipart << std::endl; // LCOV_EXCL_LINE } } From 0d0b173107507e09fa5d3ae20c76ec4b7ed6c58a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 14 Jul 2025 21:18:17 +0200 Subject: [PATCH 038/114] Further simplify eval-like operations --- .../boost/multiprecision/cpp_dec_float.hpp | 52 ++----------------- 1 file changed, 4 insertions(+), 48 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 884ff9a54..84862d231 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -3168,18 +3168,7 @@ inline void eval_add(cpp_dec_float& result, c template inline void eval_add(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) { - if (&result == &b) - { - const cpp_dec_float b_local(b); - - result = a; - result += b_local; - } - else - { - result = a; - result += b; - } + result = cpp_dec_float(a) += b; } template inline void eval_subtract(cpp_dec_float& result, const cpp_dec_float& o) @@ -3189,18 +3178,7 @@ inline void eval_subtract(cpp_dec_float& resu template inline void eval_subtract(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) { - if (&result == &b) - { - const cpp_dec_float b_local(b); - - result = a; - result -= b_local; - } - else - { - result = a; - result -= b; - } + result = cpp_dec_float(a) -= b; } template inline void eval_multiply(cpp_dec_float& result, const cpp_dec_float& o) @@ -3210,18 +3188,7 @@ inline void eval_multiply(cpp_dec_float& resu template inline void eval_multiply(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) { - if (&result == &b) - { - const cpp_dec_float b_local(b); - - result = a; - result *= b_local; - } - else - { - result = a; - result *= b; - } + result = cpp_dec_float(a) *= b; } template inline void eval_divide(cpp_dec_float& result, const cpp_dec_float& o) @@ -3231,18 +3198,7 @@ inline void eval_divide(cpp_dec_float& result template inline void eval_divide(cpp_dec_float& result, const cpp_dec_float& a, const cpp_dec_float& b) { - if (&result == &b) - { - const cpp_dec_float b_local(b); - - result = a; - result /= b_local; - } - else - { - result = a; - result /= b; - } + result = cpp_dec_float(a) /= b; } template From 7aec17719dbcaa3589e03e04794e14e0e18df23a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 12:21:32 +0200 Subject: [PATCH 039/114] Finish default_ops pow function tests --- .../multiprecision/detail/functions/pow.hpp | 7 +- test/test_pow.cpp | 73 ++++++++++++++++++- 2 files changed, 72 insertions(+), 8 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 660c9a919..ced663689 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -580,12 +580,7 @@ inline void eval_pow(T& result, const T& x, const T& a) default:; } - int s = eval_get_sign(a); - if (s == 0) - { - result = si_type(1); - return; - } + const int s = eval_get_sign(a); if (s < 0) { diff --git a/test/test_pow.cpp b/test/test_pow.cpp index 8e415d782..ef5fa7e47 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -177,6 +177,60 @@ void test_issue722() } } +template +void test_small_a_in_default_ops() +{ + // Table[N[(789/1000)^(10^(n)), 101], {n, -12, -6, 1}] + + using small_a_data_array_type = std::array; + + const small_a_data_array_type small_a_data = + {{ + T("0.99999999999976301104186376527231033639051940385775656688844414344774455623761946001430627233999497696"), + T("0.99999999999763011041864018009258589471870605197334212386735372254907219885974849025436678031854699987"), + T("0.99999999997630110418665453787411005197468225239383193650701563365941781771201272808876889833419359752"), + T("0.99999999976301104189181907356423443492950586157450272561606631208248254028299217451384055629333440182"), + T("0.99999999763011042144556021597917228924335227306284422554015278215963516103516330474932028841209422025"), + T("0.99999997630110446719254821691095026610571257635164394962451615449422537744479656992450152929555193362"), + T("0.99999976301106994561811131758260769485991144451216442896857591003045319114657385381607667593523204524") + }}; + + unsigned max_err = 0; + + std::size_t k { UINT8_C(0) }; + + const T x_val { T { 789U } / 1000 }; + + const T local_tol { std::numeric_limits::epsilon() / 4 }; + + for (int p10 = -12; p10 < -5; ++p10) + { + const T small_a { pow(T(10), p10) }; + + T val = pow(x_val, small_a); + + using std::fabs; + + const T delta { val / small_a_data[k] }; + const T closeness { fabs(1 - delta) }; + + T rel = closeness / local_tol; + + unsigned err = rel.template convert_to(); + + if (err > max_err) + { + max_err = err; + } + + ++k; + } + + std::cout << "Max error data having small a: " << max_err << std::endl; + + BOOST_TEST(max_err < 32); +} + #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) template @@ -209,9 +263,16 @@ void test() max_err = err; } } - std::cout << "Max error was: " << max_err << std::endl; + + std::cout << "Max error from data table was: " << max_err << std::endl; +#if defined(BOOST_INTEL) && defined(TEST_FLOAT128) + BOOST_TEST(max_err < 40000); +#else + BOOST_TEST(max_err < 8000); +#endif + // - // Special cases come last: + // Special cases and edge-cases come last: // BOOST_CHECK_EQUAL(pow(T(0), T(0)), 1); BOOST_CHECK_EQUAL(pow(T(0), 0), 1); @@ -355,6 +416,7 @@ int main() test(); test(); test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_MPFR_50 test(); @@ -368,6 +430,7 @@ int main() test(); test(); test_issue722(); + test_small_a_in_default_ops(); #ifndef SLOW_COMPLER // Some "peculiar" digit counts which stress our code: test > >(); @@ -390,6 +453,7 @@ int main() test(); test, long long> > >(); test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT test(); @@ -398,6 +462,11 @@ int main() test(); #endif test_issue722(); + test_small_a_in_default_ops(); + test_small_a_in_default_ops(); + #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) + test_small_a_in_default_ops(); + #endif #endif return boost::report_errors(); } From eec48fe44fd020919950234991ac84aeea528bf2 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 14:12:09 +0200 Subject: [PATCH 040/114] Streamline some syntax and more cover --- .../detail/functions/constants.hpp | 84 ++++++++++--------- .../multiprecision/detail/functions/pow.hpp | 45 +++++----- test/test_pow.cpp | 53 +++++++----- test/test_sin.cpp | 5 +- 4 files changed, 102 insertions(+), 85 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/constants.hpp b/include/boost/multiprecision/detail/functions/constants.hpp index e88a49ee4..725e88ec7 100644 --- a/include/boost/multiprecision/detail/functions/constants.hpp +++ b/include/boost/multiprecision/detail/functions/constants.hpp @@ -1,7 +1,9 @@ -// Copyright 2011 John Maddock. +// Copyright 2011 - 2025 John Maddock. +// Copyright 2025 Christopher Kormanyos. // 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) + // // This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp // @@ -10,7 +12,7 @@ template void calc_log2(T& num, unsigned digits) { using ui_type = typename boost::multiprecision::detail::canonical::type; - using si_type = typename std::tuple_element<0, typename T::signed_types>::type ; + using si_type = typename std::tuple_element<0, typename T::signed_types>::type; // // String value with 1100 digits: @@ -219,14 +221,14 @@ void calc_pi(T& result, unsigned digits) template const T& get_constant_ln2() { - static BOOST_MP_THREAD_LOCAL T result; - static BOOST_MP_THREAD_LOCAL long digits = 0; - if ((digits != boost::multiprecision::detail::digits2 >::value())) - { - boost::multiprecision::detail::maybe_promote_precision(&result); - calc_log2(result, boost::multiprecision::detail::digits2 >::value()); - digits = boost::multiprecision::detail::digits2 >::value(); - } + static const BOOST_MP_THREAD_LOCAL T result = + []() + { + T tmp_val; + boost::multiprecision::detail::maybe_promote_precision(&tmp_val); + calc_log2(tmp_val, boost::multiprecision::detail::digits2 >::value()); + return tmp_val; + }(); return result; } @@ -234,14 +236,14 @@ const T& get_constant_ln2() template const T& get_constant_e() { - static BOOST_MP_THREAD_LOCAL T result; - static BOOST_MP_THREAD_LOCAL long digits = 0; - if ((digits != boost::multiprecision::detail::digits2 >::value())) - { - boost::multiprecision::detail::maybe_promote_precision(&result); - calc_e(result, boost::multiprecision::detail::digits2 >::value()); - digits = boost::multiprecision::detail::digits2 >::value(); - } + static const BOOST_MP_THREAD_LOCAL T result = + []() + { + T tmp_val; + boost::multiprecision::detail::maybe_promote_precision(&tmp_val); + calc_e(tmp_val, boost::multiprecision::detail::digits2 >::value()); + return tmp_val; + }(); return result; } @@ -249,17 +251,18 @@ const T& get_constant_e() template const T& get_constant_pi() { - static BOOST_MP_THREAD_LOCAL T result; - static BOOST_MP_THREAD_LOCAL long digits = 0; - if ((digits != boost::multiprecision::detail::digits2 >::value())) - { - boost::multiprecision::detail::maybe_promote_precision(&result); - calc_pi(result, boost::multiprecision::detail::digits2 >::value()); - digits = boost::multiprecision::detail::digits2 >::value(); - } + static const BOOST_MP_THREAD_LOCAL T result = + []() + { + T tmp_val; + boost::multiprecision::detail::maybe_promote_precision(&tmp_val); + calc_pi(tmp_val, boost::multiprecision::detail::digits2 >::value()); + return tmp_val; + }(); return result; } + #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 4127) // conditional expression is constant @@ -267,19 +270,22 @@ const T& get_constant_pi() template const T& get_constant_one_over_epsilon() { - static BOOST_MP_THREAD_LOCAL T result; - static BOOST_MP_THREAD_LOCAL long digits = 0; - if ((digits != boost::multiprecision::detail::digits2 >::value())) - { - using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type; - boost::multiprecision::detail::maybe_promote_precision(&result); - result = static_cast(1u); - BOOST_IF_CONSTEXPR(std::numeric_limits >::is_specialized) - eval_divide(result, std::numeric_limits >::epsilon().backend()); - else - eval_ldexp(result, result, boost::multiprecision::detail::digits2 >::value() - 1); - digits = boost::multiprecision::detail::digits2 >::value(); - } + static const BOOST_MP_THREAD_LOCAL T result = + []() + { + using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type; + + T tmp_val; + boost::multiprecision::detail::maybe_promote_precision(&tmp_val); + tmp_val = static_cast(1u); + + BOOST_IF_CONSTEXPR(std::numeric_limits >::is_specialized) + eval_divide(tmp_val, std::numeric_limits >::epsilon().backend()); + else + eval_ldexp(tmp_val, tmp_val, boost::multiprecision::detail::digits2 >::value() - 1); + + return tmp_val; + }(); return result; } diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index ced663689..bd9ef88c9 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -8,6 +8,7 @@ // This work is based on an earlier work: // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 + // // This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp // @@ -99,7 +100,7 @@ inline void pow_imp(T& result, const T& t, const U& p, const std::integral_const { // Signed integer power, just take care of the sign then call the unsigned version: using int_type = typename boost::multiprecision::detail::canonical::type; - using ui_type = typename boost::multiprecision::detail::make_unsigned::type ; + using ui_type = typename boost::multiprecision::detail::make_unsigned::type; if (p < 0) { @@ -163,7 +164,7 @@ void hyp0F0(T& H0F0, const T& x) x_pow_n_div_n_fact.negate(); } if (n >= series_limit) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("H0F0 failed to converge")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("H0F0 failed to converge")); // LCOV_EXCL_LINE } template @@ -212,7 +213,7 @@ void hyp1F0(T& H1F0, const T& a, const T& x) break; } if (n >= series_limit) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("H1F0 failed to converge")); + BOOST_MP_THROW_EXCEPTION(std::runtime_error("H1F0 failed to converge")); // LCOV_EXCL_LINE } template @@ -227,8 +228,8 @@ void eval_exp(T& result, const T& x) return; } using ui_type = typename boost::multiprecision::detail::canonical::type; - using si_type = typename boost::multiprecision::detail::canonical::type ; - using exp_type = typename T::exponent_type ; + using si_type = typename boost::multiprecision::detail::canonical::type; + using exp_type = typename T::exponent_type; using canonical_exp_type = typename boost::multiprecision::detail::canonical::type; // Handle special arguments. @@ -373,10 +374,12 @@ void eval_log(T& result, const T& arg) // log(x) = log(2) * n + log1p(1 + y) // using ui_type = typename boost::multiprecision::detail::canonical::type; - using exp_type = typename T::exponent_type ; + using exp_type = typename T::exponent_type; using canonical_exp_type = typename boost::multiprecision::detail::canonical::type; - using fp_type = typename std::tuple_element<0, typename T::float_types>::type ; - int s = eval_signbit(arg); + using fp_type = typename std::tuple_element<0, typename T::float_types>::type; + + const int s = eval_signbit(arg); + switch (eval_fpclassify(arg)) { case FP_NAN: @@ -455,16 +458,14 @@ void eval_log(T& result, const T& arg) template const T& get_constant_log10() { - static BOOST_MP_THREAD_LOCAL T result; - static BOOST_MP_THREAD_LOCAL long digits = 0; - if ((digits != boost::multiprecision::detail::digits2 >::value())) - { - using ui_type = typename boost::multiprecision::detail::canonical::type; - T ten; - ten = ui_type(10u); - eval_log(result, ten); - digits = boost::multiprecision::detail::digits2 >::value(); - } + static const BOOST_MP_THREAD_LOCAL T result = + []() + { + const T ten(10); + T tmp_val; + eval_log(tmp_val, ten); + return tmp_val; + }(); return result; } @@ -555,7 +556,7 @@ inline void eval_pow(T& result, const T& x, const T& a) return; } } - BOOST_MP_CATCH(const std::exception&) + BOOST_MP_CATCH(const std::exception&) // LCOV_EXCL_LINE { // fallthrough.. } @@ -679,7 +680,7 @@ inline void eval_pow(T& result, const T& x, const T& a) } else { - BOOST_MP_THROW_EXCEPTION(std::domain_error("Result of pow is undefined or non-real and there is no NaN for this number type.")); + BOOST_MP_THROW_EXCEPTION(std::domain_error("Result of pow is undefined or non-real and there is no NaN for this number type.")); // LCOV_EXCL_LINE } return; } @@ -746,7 +747,7 @@ template #if BOOST_WORKAROUND(BOOST_MSVC, < 1800) inline typename std::enable_if::value, void>::type #else -inline typename std::enable_if >::value && !boost::multiprecision::detail::is_integral::value, void>::type +inline typename std::enable_if >::value && !boost::multiprecision::detail::is_integral::value, void>::type #endif eval_pow(T& result, const T& x, const A& a) { @@ -763,7 +764,7 @@ template #if BOOST_WORKAROUND(BOOST_MSVC, < 1800) inline void #else -inline typename std::enable_if >::value, void>::type +inline typename std::enable_if >::value, void>::type #endif eval_pow(T& result, const A& x, const T& a) { diff --git a/test/test_pow.cpp b/test/test_pow.cpp index ef5fa7e47..cbee53abe 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -9,6 +9,14 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 +#define TEST_CPP_BIN_FLOAT +#define TEST_CPP_DEC_FLOAT +#define TEST_CPP_DOUBLE_FLOAT +#if defined(__GNUC__) +#define TEST_FLOAT128 +#define TEST_MPF_50 +#endif + #ifdef _MSC_VER #define _SCL_SECURE_NO_WARNINGS #endif @@ -66,13 +74,14 @@ #include #endif -#if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) +#if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) // These were the only ones I checked locally at the moment that use random tests. +#include #include #include -#endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) +#endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) template auto my_zero() -> FloatType&; @@ -127,7 +136,7 @@ namespace local { } // namespace local -#if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) +#if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) // These were the only ones I checked locally at the moment. @@ -195,26 +204,26 @@ void test_small_a_in_default_ops() T("0.99999976301106994561811131758260769485991144451216442896857591003045319114657385381607667593523204524") }}; - unsigned max_err = 0; + unsigned max_err = 0U; - std::size_t k { UINT8_C(0) }; + const T x_val(T(789U) / 1000); - const T x_val { T { 789U } / 1000 }; + const T local_tol { std::numeric_limits::epsilon() / 8 }; - const T local_tol { std::numeric_limits::epsilon() / 4 }; + T small_a = pow(T(10), -12); - for (int p10 = -12; p10 < -5; ++p10) + for (std::size_t k { UINT8_C(0) }; k < std::tuple_size::value; ++k) { - const T small_a { pow(T(10), p10) }; + const T val = pow(x_val, small_a); - T val = pow(x_val, small_a); + small_a *= 10; using std::fabs; const T delta { val / small_a_data[k] }; const T closeness { fabs(1 - delta) }; - T rel = closeness / local_tol; + const T rel = closeness / local_tol; unsigned err = rel.template convert_to(); @@ -222,16 +231,14 @@ void test_small_a_in_default_ops() { max_err = err; } - - ++k; } std::cout << "Max error data having small a: " << max_err << std::endl; - BOOST_TEST(max_err < 32); + BOOST_TEST(max_err < 64U); } -#endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) +#endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) template void test() @@ -245,7 +252,7 @@ void test() const auto& data = local::data_maker::get_data(); - unsigned max_err = 0; + unsigned max_err = 0U; for (unsigned k = 0; k < data.size(); k++) { T val = pow(T(data[k][0]), T(data[k][1])); @@ -266,9 +273,9 @@ void test() std::cout << "Max error from data table was: " << max_err << std::endl; #if defined(BOOST_INTEL) && defined(TEST_FLOAT128) - BOOST_TEST(max_err < 40000); + BOOST_TEST(max_err < 40000U); #else - BOOST_TEST(max_err < 8000); + BOOST_TEST(max_err < 8000U); #endif // @@ -283,7 +290,7 @@ void test() BOOST_CHECK_EQUAL(pow(T(1), T(2)), 1); BOOST_CHECK_EQUAL(pow(T(1), 2), 1); - #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) // These were the only ones I checked locally at the moment. std::mt19937_64 gen { }; @@ -297,7 +304,7 @@ void test() static_cast(1.04L) ); - #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) BOOST_IF_CONSTEXPR(std::numeric_limits::is_specialized && std::numeric_limits::has_infinity) { @@ -305,7 +312,7 @@ void test() BOOST_CHECK_EQUAL(pow(T(1.25F), -std::numeric_limits::infinity()), T(0)); - #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + #if (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) // These were the only ones I checked locally at the moment. for (int npow = -8; npow < 8; ++npow) @@ -377,7 +384,7 @@ void test() } } - #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50) || defined(TEST_FLOAT128)) } BOOST_IF_CONSTEXPR((!boost::multiprecision::is_interval_number::value) && std::numeric_limits::is_specialized && std::numeric_limits::has_quiet_NaN) @@ -448,6 +455,8 @@ int main() #endif #ifdef TEST_FLOAT128 test(); + test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_CPP_BIN_FLOAT test(); diff --git a/test/test_sin.cpp b/test/test_sin.cpp index 5698980d4..e1da3a131 100644 --- a/test/test_sin.cpp +++ b/test/test_sin.cpp @@ -13,10 +13,9 @@ #define _SCL_SECURE_NO_WARNINGS #endif -#include +#include #include -#include "test.hpp" #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DOUBLE_FLOAT) #define TEST_MPF_50 @@ -64,6 +63,8 @@ #include #endif +#include + template struct has_poor_large_value_support { From 0d3a7a21bd191be37f82e6831c6bf83bd9af1381 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 14:30:23 +0200 Subject: [PATCH 041/114] Correct a syntax error --- include/boost/multiprecision/detail/functions/pow.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index bd9ef88c9..4f297d0cf 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -461,7 +461,9 @@ const T& get_constant_log10() static const BOOST_MP_THREAD_LOCAL T result = []() { - const T ten(10); + using ui_type = typename boost::multiprecision::detail::canonical::type; + T ten; + ten = ui_type(10u); T tmp_val; eval_log(tmp_val, ten); return tmp_val; From 4dce9aaffd6648a8d2af8fe99204c736b6517e8e Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 15:15:45 +0200 Subject: [PATCH 042/114] Remove forgotten local test code --- test/test_pow.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/test/test_pow.cpp b/test/test_pow.cpp index cbee53abe..6a11411b4 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -9,14 +9,6 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 -#define TEST_CPP_BIN_FLOAT -#define TEST_CPP_DEC_FLOAT -#define TEST_CPP_DOUBLE_FLOAT -#if defined(__GNUC__) -#define TEST_FLOAT128 -#define TEST_MPF_50 -#endif - #ifdef _MSC_VER #define _SCL_SECURE_NO_WARNINGS #endif From 1404c25d4bd22dc7bd4377a4cfa42ed80f49ae9c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 18:00:25 +0200 Subject: [PATCH 043/114] Revert constants changes and query later --- .../detail/functions/constants.hpp | 83 +++++++++---------- .../multiprecision/detail/functions/pow.hpp | 20 ++--- 2 files changed, 49 insertions(+), 54 deletions(-) diff --git a/include/boost/multiprecision/detail/functions/constants.hpp b/include/boost/multiprecision/detail/functions/constants.hpp index 725e88ec7..13f5177ec 100644 --- a/include/boost/multiprecision/detail/functions/constants.hpp +++ b/include/boost/multiprecision/detail/functions/constants.hpp @@ -1,9 +1,7 @@ -// Copyright 2011 - 2025 John Maddock. -// Copyright 2025 Christopher Kormanyos. +// Copyright 2011 John Maddock. // 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) - // // This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp // @@ -221,14 +219,14 @@ void calc_pi(T& result, unsigned digits) template const T& get_constant_ln2() { - static const BOOST_MP_THREAD_LOCAL T result = - []() - { - T tmp_val; - boost::multiprecision::detail::maybe_promote_precision(&tmp_val); - calc_log2(tmp_val, boost::multiprecision::detail::digits2 >::value()); - return tmp_val; - }(); + static BOOST_MP_THREAD_LOCAL T result; + static BOOST_MP_THREAD_LOCAL long digits = 0; + if ((digits != boost::multiprecision::detail::digits2 >::value())) + { + boost::multiprecision::detail::maybe_promote_precision(&result); + calc_log2(result, boost::multiprecision::detail::digits2 >::value()); + digits = boost::multiprecision::detail::digits2 >::value(); + } return result; } @@ -236,14 +234,14 @@ const T& get_constant_ln2() template const T& get_constant_e() { - static const BOOST_MP_THREAD_LOCAL T result = - []() - { - T tmp_val; - boost::multiprecision::detail::maybe_promote_precision(&tmp_val); - calc_e(tmp_val, boost::multiprecision::detail::digits2 >::value()); - return tmp_val; - }(); + static BOOST_MP_THREAD_LOCAL T result; + static BOOST_MP_THREAD_LOCAL long digits = 0; + if ((digits != boost::multiprecision::detail::digits2 >::value())) + { + boost::multiprecision::detail::maybe_promote_precision(&result); + calc_e(result, boost::multiprecision::detail::digits2 >::value()); + digits = boost::multiprecision::detail::digits2 >::value(); + } return result; } @@ -251,18 +249,18 @@ const T& get_constant_e() template const T& get_constant_pi() { - static const BOOST_MP_THREAD_LOCAL T result = - []() - { - T tmp_val; - boost::multiprecision::detail::maybe_promote_precision(&tmp_val); - calc_pi(tmp_val, boost::multiprecision::detail::digits2 >::value()); - return tmp_val; - }(); + static BOOST_MP_THREAD_LOCAL T result; + static BOOST_MP_THREAD_LOCAL long digits = 0; + + if ((digits != boost::multiprecision::detail::digits2 >::value())) + { + boost::multiprecision::detail::maybe_promote_precision(&result); + calc_pi(result, boost::multiprecision::detail::digits2 >::value()); + digits = boost::multiprecision::detail::digits2 >::value(); + } return result; } - #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 4127) // conditional expression is constant @@ -270,22 +268,19 @@ const T& get_constant_pi() template const T& get_constant_one_over_epsilon() { - static const BOOST_MP_THREAD_LOCAL T result = - []() - { - using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type; - - T tmp_val; - boost::multiprecision::detail::maybe_promote_precision(&tmp_val); - tmp_val = static_cast(1u); - - BOOST_IF_CONSTEXPR(std::numeric_limits >::is_specialized) - eval_divide(tmp_val, std::numeric_limits >::epsilon().backend()); - else - eval_ldexp(tmp_val, tmp_val, boost::multiprecision::detail::digits2 >::value() - 1); - - return tmp_val; - }(); + static BOOST_MP_THREAD_LOCAL T result; + static BOOST_MP_THREAD_LOCAL long digits = 0; + if ((digits != boost::multiprecision::detail::digits2 >::value())) + { + using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type; + boost::multiprecision::detail::maybe_promote_precision(&result); + result = static_cast(1u); + BOOST_IF_CONSTEXPR(std::numeric_limits >::is_specialized) + eval_divide(result, std::numeric_limits >::epsilon().backend()); + else + eval_ldexp(result, result, boost::multiprecision::detail::digits2 >::value() - 1); + digits = boost::multiprecision::detail::digits2 >::value(); + } return result; } diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 4f297d0cf..4a7a3f210 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -458,16 +458,16 @@ void eval_log(T& result, const T& arg) template const T& get_constant_log10() { - static const BOOST_MP_THREAD_LOCAL T result = - []() - { - using ui_type = typename boost::multiprecision::detail::canonical::type; - T ten; - ten = ui_type(10u); - T tmp_val; - eval_log(tmp_val, ten); - return tmp_val; - }(); + static BOOST_MP_THREAD_LOCAL T result; + static BOOST_MP_THREAD_LOCAL long digits = 0; + if ((digits != boost::multiprecision::detail::digits2 >::value())) + { + using ui_type = typename boost::multiprecision::detail::canonical::type; + T ten; + ten = ui_type(10u); + eval_log(result, ten); + digits = boost::multiprecision::detail::digits2 >::value(); + } return result; } From 618132d3bdc75cce66e6b8ea473de4253e112ed3 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 15 Jul 2025 20:27:23 +0200 Subject: [PATCH 044/114] More pretty printing test progress --- test/test_cos_near_half_pi.cpp | 28 ++++++++++++++++++---------- test/test_sin_near_half_pi.cpp | 24 ++++++++++++++++++------ 2 files changed, 36 insertions(+), 16 deletions(-) diff --git a/test/test_cos_near_half_pi.cpp b/test/test_cos_near_half_pi.cpp index 00b0fb371..273204015 100644 --- a/test/test_cos_near_half_pi.cpp +++ b/test/test_cos_near_half_pi.cpp @@ -1,6 +1,7 @@ /////////////////////////////////////////////////////////////// -// Copyright Christopher Kormanyos 2002 - 2011. -// Copyright 2011 John Maddock. Distributed under the Boost +// Copyright 2011 - 2025 John Maddock. +// Copyright Christopher Kormanyos 2002 - 2025. +// Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt // @@ -12,10 +13,10 @@ #define _SCL_SECURE_NO_WARNINGS #endif +#include + #include -#include #include -#include "test.hpp" #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_MPFR_50) #define TEST_MPF_50 @@ -48,14 +49,23 @@ #include #endif +#include + template void test() { - typedef boost::multiprecision::number > mpfr_float_1000; + std::cout << "Testing type: " << typeid(T).name() << std::endl; + std::cout << "Round: n="; for (int n = -20; n <= 20; ++n) { - std::cout << "Testing n = " << n << std::endl; + if (n != -20) + std::cout << ","; + + std::cout << n; + + using mpfr_float_1000 = boost::multiprecision::number>; + T boundary = boost::math::constants::half_pi() * n; T val = boundary; for (unsigned i = 0; i < 200; ++i) @@ -65,10 +75,6 @@ void test() T found = cos(val); T expected = T(comparison); BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20); - //std::cout << std::setprecision(10) << val << std::endl; - //std::cout << std::setprecision(50) << found << std::endl; - //std::cout << std::setprecision(50) << comparison << std::endl; - //std::cout << std::setprecision(50) << expected << std::endl; val = boost::math::float_next(val); } val = boundary; @@ -82,6 +88,8 @@ void test() BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20); } } + + std::cout << std::endl; } int main() diff --git a/test/test_sin_near_half_pi.cpp b/test/test_sin_near_half_pi.cpp index e62308aa2..a4d27aba0 100644 --- a/test/test_sin_near_half_pi.cpp +++ b/test/test_sin_near_half_pi.cpp @@ -1,6 +1,7 @@ /////////////////////////////////////////////////////////////// -// Copyright Christopher Kormanyos 2002 - 2011. -// Copyright 2011 John Maddock. Distributed under the Boost +// Copyright 2011 - 2025 John Maddock. +// Copyright Christopher Kormanyos 2002 - 2025. +// Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt // @@ -12,10 +13,10 @@ #define _SCL_SECURE_NO_WARNINGS #endif +#include + #include -#include #include -#include "test.hpp" #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_MPFR_50) #define TEST_MPF_50 @@ -48,14 +49,23 @@ #include #endif +#include + template void test() { - typedef boost::multiprecision::number > mpfr_float_1000; + std::cout << "Testing type: " << typeid(T).name() << std::endl; + std::cout << "Round: n="; for (int n = 0; n <= 20; ++n) { - std::cout << "Testing n = " << n << std::endl; + if (n != 0) + std::cout << ","; + + std::cout << n; + + using mpfr_float_1000 = boost::multiprecision::number>; + T boundary = boost::math::constants::half_pi() * n; T val = boundary; if((n == 0) && ((std::numeric_limits::min_exponent <= std::numeric_limits::min_exponent) || (!std::numeric_limits::is_specialized))) @@ -80,6 +90,8 @@ void test() BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20); } } + + std::cout << std::endl; } int main() From e4aada54895f6c4486a8a99ef159358e9881b480 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 19 Jul 2025 22:30:57 +0200 Subject: [PATCH 045/114] More tests and syntax --- .../boost/multiprecision/cpp_double_fp.hpp | 73 +++++++---- .../multiprecision/detail/functions/pow.hpp | 2 +- .../multiprecision/detail/functions/trig.hpp | 2 +- test/test_exp.cpp | 117 ++++++++++++++---- test/test_pow.cpp | 1 + test/test_various_edges_more.cpp | 69 ++++++++--- 6 files changed, 199 insertions(+), 65 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 844b26958..f88f4fbda 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -168,6 +168,9 @@ namespace backends { // The type of the floating-point constituents should adhere to IEEE754. // This class has been tested with floats having single-precision (4 byte), // double-precision (8 byte) and quad precision (16 byte, such as GCC's __float128). +// Although the constituent parts (a0 and a1) satisfy |a1| <= (1 / 2) * ulp(a0), +// the composite type does not adhere to these strict error bounds. Its error +// bounds are larger. template class cpp_double_fp_backend @@ -184,7 +187,7 @@ class cpp_double_fp_backend || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 53) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 64) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113) - }, "Error: float_type does not fulfil the backend requirements of cpp_double_fp_backend" + }, "Error: float_type does not fulfill the backend requirements of cpp_double_fp_backend" ); using rep_type = cpp_df_qf_detail::pair; @@ -317,7 +320,7 @@ class cpp_double_fp_backend && ((static_cast(sizeof(SignedIntegralType) * 8) - 1) > cpp_df_qf_detail::ccmath::numeric_limits::digits))>::type const* = nullptr> constexpr cpp_double_fp_backend(SignedIntegralType n) { - const bool is_neg { n < SignedIntegralType { INT8_C(0) } }; + const bool is_neg { (n < SignedIntegralType { INT8_C(0) }) }; using local_unsigned_integral_type = typename boost::multiprecision::detail::make_unsigned::type; @@ -436,7 +439,14 @@ class cpp_double_fp_backend constexpr auto iszero_unchecked() const noexcept -> bool { return (data.first == float_type { 0.0F }); } - constexpr auto is_one() const noexcept -> bool { return ((data.second == float_type { 0.0F }) && (data.first == float_type { 1.0F })); } + constexpr auto is_one() const noexcept -> bool + { + return + ( + (data.second == float_type { 0.0F }) + && (data.first == float_type { 1.0F }) + ); + } constexpr auto negate() -> void { @@ -714,7 +724,8 @@ class cpp_double_fp_backend // The division algorithm has been taken from Victor Shoup, // package WinNTL-5_3_2. It might originally be related to the // K. Briggs work. The algorithm has been significantly simplified - // while still atempting to retain proper rounding corrections. + // while still attempting to retain proper rounding corrections. + // Checks for overflow and underflow have been added. const float_type C { data.first / v.data.first }; @@ -762,11 +773,11 @@ class cpp_double_fp_backend u = cpp_df_qf_detail::ccmath::unsafe::fma(hc, hv, -U); - const float_type tv { v.data.first - hv }; + { + const float_type tv { v.data.first - hv }; - u = cpp_df_qf_detail::ccmath::unsafe::fma(hc, tv, u); + u = cpp_df_qf_detail::ccmath::unsafe::fma(hc, tv, u); - { const float_type tc { C - hc }; u = cpp_df_qf_detail::ccmath::unsafe::fma(tc, hv, u); @@ -1028,7 +1039,8 @@ class cpp_double_fp_backend // The multiplication algorithm has been taken from Victor Shoup, // package WinNTL-5_3_2. It might originally be related to the // K. Briggs work. The algorithm has been significantly simplified - // while still atempting to retain proper rounding corrections. + // while still attempting to retain proper rounding corrections. + // Checks for overflow and underflow have been added. float_type C { cpp_df_qf_detail::split_maker::value * data.first }; @@ -1081,19 +1093,26 @@ class cpp_double_fp_backend hv = c - float_type { c - v.data.first }; } - const float_type tv { v.data.first - hv }; - - float_type t1 { cpp_df_qf_detail::ccmath::unsafe::fma(hu, hv, -C) }; - - t1 = cpp_df_qf_detail::ccmath::unsafe::fma(hu, tv, t1); + { + const float_type tv { v.data.first - hv }; - const float_type tu { data.first - hu }; + const float_type + t1 + { + cpp_df_qf_detail::ccmath::unsafe::fma + ( + hu, + tv, + cpp_df_qf_detail::ccmath::unsafe::fma(hu, hv, -C) + ) + }; - t1 = cpp_df_qf_detail::ccmath::unsafe::fma(tu, hv, t1); + const float_type tu { data.first - hu }; - c = cpp_df_qf_detail::ccmath::unsafe::fma(tu, tv, t1) - + (data.first * v.data.second) - + (data.second * v.data.first); + c = cpp_df_qf_detail::ccmath::unsafe::fma(tu, tv, cpp_df_qf_detail::ccmath::unsafe::fma(tu, hv, t1)) + + (data.first * v.data.second) + + (data.second * v.data.first); + } // Perform even more simplifications compared to Victor Shoup. data.first = C + c; @@ -1116,13 +1135,13 @@ class cpp_double_fp_backend template auto cpp_double_fp_backend::rd_string(const char* pstr) -> bool { - using local_double_fp_type = cpp_double_fp_backend; - cpp_bin_float_read_write_type f_bin { pstr }; - const auto fpc = fpclassify(f_bin); + const int fpc { fpclassify(f_bin) }; - const auto is_definitely_nan = (fpc == FP_NAN); + const bool is_definitely_nan { (fpc == FP_NAN) }; + + using local_double_fp_type = cpp_double_fp_backend; if (is_definitely_nan) { @@ -1562,7 +1581,7 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const template -constexpr auto eval_pow(cpp_double_fp_backend& result, const cpp_double_fp_backend& x, IntegralType p) -> typename ::std::enable_if::value, void>::type +constexpr auto eval_pow(cpp_double_fp_backend& result, const cpp_double_fp_backend& x, IntegralType p) -> typename ::std::enable_if<::boost::multiprecision::detail::is_integral::value, void>::type { const int fpc { eval_fpclassify(x) }; @@ -2503,11 +2522,11 @@ auto hash_value(const cpp_double_fp_backend& a) -> ::std::siz using backends::cpp_double_fp_backend; -using cpp_double_float = number, boost::multiprecision::et_off>; -using cpp_double_double = number, boost::multiprecision::et_off>; -using cpp_double_long_double = number, boost::multiprecision::et_off>; +using cpp_double_float = number, ::boost::multiprecision::et_off>; +using cpp_double_double = number, ::boost::multiprecision::et_off>; +using cpp_double_long_double = number, ::boost::multiprecision::et_off>; #ifdef BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128 -using cpp_double_float128 = number, boost::multiprecision::et_off>; +using cpp_double_float128 = number, ::boost::multiprecision::et_off>; #endif } } // namespace boost::multiprecision diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 4a7a3f210..e79aacff1 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -672,7 +672,7 @@ inline void eval_pow(T& result, const T& x, const T& a) } else { - result = std::numeric_limits >::infinity().backend(); + result = std::numeric_limits >::infinity().backend(); // LCOV_EXCL_LINE There is no NaN for this number type. } } else BOOST_IF_CONSTEXPR (std::numeric_limits >::has_quiet_NaN) diff --git a/include/boost/multiprecision/detail/functions/trig.hpp b/include/boost/multiprecision/detail/functions/trig.hpp index 02442a2f5..7d028869a 100644 --- a/include/boost/multiprecision/detail/functions/trig.hpp +++ b/include/boost/multiprecision/detail/functions/trig.hpp @@ -170,7 +170,7 @@ void eval_sin(T& result, const T& x) using si_type = typename boost::multiprecision::detail::canonical::type ; using ui_type = typename boost::multiprecision::detail::canonical::type; - using fp_type = typename std::tuple_element<0, typename T::float_types>::type ; + using fp_type = typename std::tuple_element<0, typename T::float_types>::type; switch (eval_fpclassify(x)) { diff --git a/test/test_exp.cpp b/test/test_exp.cpp index 92eaf7419..b3f17294e 100644 --- a/test/test_exp.cpp +++ b/test/test_exp.cpp @@ -17,14 +17,11 @@ #include #include - -#include -#include -#include +#include #if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_CPP_DOUBLE_FLOAT) #define TEST_MPF_50 -//# define TEST_MPF +//#define TEST_MPF #define TEST_BACKEND #define TEST_CPP_DEC_FLOAT #define TEST_MPFI_50 @@ -68,6 +65,13 @@ #include #endif +#include +#include +#include + +template auto my_zero() -> FloatType&; +template auto my_one() -> FloatType&; + template void test() { @@ -77,7 +81,9 @@ void test() BOOST_IF_CONSTEXPR (std::numeric_limits::is_specialized && (std::numeric_limits::max_exponent10 > 4000)) { - static const std::array data = + using table_data_array_type = std::array; + + static const table_data_array_type table_data = {{ "1.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.47747587596218770242116751705184563668845029215054154915126374673142219159548534317576897266130328412495991561490384353e76", @@ -132,26 +138,31 @@ void test() "6.83336127500041943234365059231968669406267422759442985746460610830503287734479988530512309065240678799786759250323660701e3848", }}; - T pi = static_cast("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609"); + const T pi = static_cast("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609"); - for (unsigned k = 0; k < data.size(); k++) + for (unsigned k = 0u; k < static_cast(std::tuple_size::value); ++k) { - T val = exp(sqrt((pi * (100 * k)) * (100 * k))); - T e = relative_error(val, T(data[k])); + T val = exp(sqrt((pi * (100u * k)) * (100u * k))); + T e = relative_error(val, T(table_data[k])); + unsigned err = e.template convert_to(); + if (err > max_err) { max_err = err; } - val = exp(-sqrt((pi * (100 * k)) * (100 * k))); - e = relative_error(val, T(1 / T(data[k]))); + + val = exp(-sqrt((pi * (100u * k)) * (100u * k))); + e = relative_error(val, T(1 / T(table_data[k]))); + err = e.template convert_to(); + if (err > max_err) { max_err = err; } } - std::cout << "Max error was: " << max_err << std::endl; + std::cout << "Max error table_data was: " << max_err << std::endl; #if defined(BOOST_INTEL) && defined(TEST_FLOAT128) BOOST_TEST(max_err < 40000); #elif defined(TEST_CPP_BIN_FLOAT) @@ -163,7 +174,10 @@ void test() using std::ldexp; - static const std::array, 12> exact_data = + using exact_data_pair_type = std::array; + using exact_data_array_type = std::array; + + static const exact_data_array_type exact_data = {{ {{ldexp(1.0, -50), static_cast("1.000000000000000888178419700125626769357944978675730736309709508287711059579809241499236575743374705946980126761002249532899810120773330275600867188192232364653350140592709328919189811425580736404494785")}}, {{ldexp(1.0, -20), static_cast("1.00000095367477115374544678824955687428365188553281789775169686343569285229334215539516690752571791280462887427635269562079697496032436580742164524046357050365736415701568566320292733574692386949329504")}}, @@ -175,42 +189,83 @@ void test() {{10.5, static_cast("36315.5026742466377389120269013166179689315579671275857607480190550842856628099187749764427758174866310742771977376827511779240563292392413797025035252944088473059613508585937585174897482367249804575829")}}, {{25, static_cast("7.20048993373858725241613514661261579152235338133952787362213864472320593107782569745000325654258093194727871848859163683530731259683905547347259346394203424381962487428148616548084393082148632398178103e10")}}, {{31.25, static_cast("3.72994612957188849046766396046821396700589012875701157893019118883826370993674081486706667149871508642909416337810227575115729423667289322729813729072376711271966343652718317681492250090327804073781915e13")}}, + // N[Log[39614081257132168796771975168], 201] {{static_cast("65.8489821531948043946370515385267739671725127642242491414646009018723940871209979825570160646597753164901406969542151447001244223970224029181037214053322163834191192286952863430791686692697089797567183"), static_cast("39614081257132168796771975168.0")}}, + // N[Log[19807040628566084398385987584], 201] {{static_cast("65.1558349726348590852198194170685973990970126298639938873439208923790004651513032669511527376633566289481392159336444589664389021612642723610710506536971404214883916578669149078888616306458173062855949"), static_cast("19807040628566084398385987584.0")}}, }}; max_err = 0; - for (unsigned k = 0; k < exact_data.size(); k++) + for (unsigned k = 0u; k < static_cast(std::tuple_size::value); ++k) { - T val = exp(exact_data[k][0]); - T e = relative_error(val, exact_data[k][1]); + T val = exp(exact_data[k][0]); + T e = relative_error(val, exact_data[k][1]); + unsigned err = e.template convert_to(); + if (err > max_err) { max_err = err; } + val = exp(-exact_data[k][0]); e = relative_error(val, T(1 / exact_data[k][1])); + err = e.template convert_to(); + if (err > max_err) { max_err = err; } } - std::cout << "Max error was: " << max_err << std::endl; + std::cout << "Max error exact_data was: " << max_err << std::endl; BOOST_TEST(max_err < 60); - BOOST_TEST(exp(T(0)) == 1); - - if (!boost::multiprecision::is_interval_number::value) + BOOST_IF_CONSTEXPR (!boost::multiprecision::is_interval_number::value) { + std::mt19937_64 gen { }; + + gen.seed(static_cast(std::clock())); + + std::uniform_real_distribution + dist + ( + static_cast(1.01L), + static_cast(1.04L) + ); + + for (int index = 0; index < 8; ++index) + { + static_cast(index); + + const T val_zero { ::my_zero() * dist(gen) }; + + const T exp_zero = exp(val_zero); + + BOOST_CHECK(exp_zero == ::my_one()); + } + + BOOST_IF_CONSTEXPR (std::numeric_limits::is_specialized) + { + for (int index = 0; index < 8; ++index) + { + static_cast(index); + + const T val_one(static_cast(::my_one() * dist(gen))); + + const T exp_one = exp(val_one); + + BOOST_CHECK_CLOSE_FRACTION(exp_one, boost::math::constants::e(), std::numeric_limits::epsilon() * 4); + } + } + T bug_case = -1.05 * log((std::numeric_limits::max)()); for (unsigned i = 0U; bug_case > -20 / std::numeric_limits::epsilon(); ++i, bug_case *= 1.05) { static_cast(i); - if (std::numeric_limits::has_infinity) + BOOST_IF_CONSTEXPR (std::numeric_limits::has_infinity) { BOOST_CHECK_EQUAL(exp(bug_case), 0); } @@ -290,3 +345,21 @@ int main() #endif return boost::report_errors(); } + +template auto my_zero() -> FloatType& +{ + using float_type = FloatType; + + static float_type my_val_zero(0); + + return my_val_zero; +} + +template auto my_one() -> FloatType& +{ + using float_type = FloatType; + + static float_type my_val_one(1); + + return my_val_one; +} diff --git a/test/test_pow.cpp b/test/test_pow.cpp index 6a11411b4..18334aa36 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -25,6 +25,7 @@ //# define TEST_MPF #define TEST_BACKEND #define TEST_CPP_DEC_FLOAT +#define TEST_FLOAT128 #define TEST_MPFR_50 #define TEST_MPFI_50 #define TEST_CPP_BIN_FLOAT diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index d37d95d9b..222b9e4f6 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -625,6 +625,47 @@ namespace local return result_is_ok; } + template + bool test_edges_trig() + { + using float_type = FloatType; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.01F), + static_cast(1.04F) + }; + + bool result_is_ok { true }; + + using std::isinf; + using std::isnan; + using std::signbit; + + BOOST_IF_CONSTEXPR(std::numeric_limits::has_quiet_NaN) + { + std::mt19937_64 gen { UINT64_C(0xF00DCAFEDEADBEEF) }; + + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(8)); ++index) + { + static_cast(index); + + float_type flt_nan = std::numeric_limits::quiet_NaN() * dis(gen); + + const float_type atan_nan = atan(flt_nan); + + const bool result_atan_nan_is_ok { (boost::multiprecision::isnan)(atan_nan) && ((boost::multiprecision::fpclassify)(atan_nan) == FP_NAN) }; + + BOOST_TEST(result_atan_nan_is_ok); + + result_is_ok = (result_atan_nan_is_ok && result_is_ok); + } + } + + return result_is_ok; + } + template auto test_convert_and_back_caller(const float epsilon_factor = 0.0F) -> bool { @@ -790,27 +831,27 @@ namespace local auto main() -> int { - { - using float_backend_type = boost::multiprecision::cpp_bin_float<50>; + using bin_float_backend_type = boost::multiprecision::cpp_bin_float<50>; + using dec_float_backend_type = boost::multiprecision::cpp_dec_float<50>; - using float_type = boost::multiprecision::number; + using bin_float_type = boost::multiprecision::number; + using dec_float_type = boost::multiprecision::number; - std::cout << "Testing type: " << typeid(float_type).name() << std::endl; + { + std::cout << "Testing type: " << typeid(bin_float_type).name() << std::endl; - static_cast(local::test_edges()); + static_cast(local::test_edges()); + static_cast(local::test_edges_trig()); } { - using float_backend_type = boost::multiprecision::cpp_dec_float<50>; - - using float_type = boost::multiprecision::number; - - std::cout << "Testing type: " << typeid(float_type).name() << std::endl; + std::cout << "Testing type: " << typeid(dec_float_type).name() << std::endl; - static_cast(local::test_edges()); - local::test_cpp_dec_float_rd_ovf_unf(); - local::test_convert_and_back(0.0F); - local::test_cpp_dec_float_frexp_edge(); + static_cast(local::test_edges()); + static_cast(local::test_edges_trig()); + local::test_cpp_dec_float_rd_ovf_unf(); + local::test_convert_and_back(0.0F); + local::test_cpp_dec_float_frexp_edge(); } { From 80609b22a2b2f1a4efd39ca20c6fc6064e8c2daf Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 21 Jul 2025 09:29:01 +0200 Subject: [PATCH 046/114] Refactor from-u-long-long and an example --- example/exercise_threading_log_agm.cpp | 132 ++++++++++-------- .../boost/multiprecision/cpp_dec_float.hpp | 47 +++++-- 2 files changed, 113 insertions(+), 66 deletions(-) diff --git a/example/exercise_threading_log_agm.cpp b/example/exercise_threading_log_agm.cpp index 10ce93004..69d88fb5d 100644 --- a/example/exercise_threading_log_agm.cpp +++ b/example/exercise_threading_log_agm.cpp @@ -1,5 +1,5 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright Christopher Kormanyos 2020 - 2021. +// Copyright Christopher Kormanyos 2020 - 2025. // 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) @@ -25,24 +25,28 @@ // We find the following performance data here: // https://github.com/boostorg/multiprecision/pull/213 // +// New numbers 2025-07-20 at 301 decimal digits +// -------------------------------------------- +// // cpp_dec_float: -// result_is_ok_concurrent: true, calculation_time_concurrent: 18.1s -// result_is_ok_sequential: true, calculation_time_sequential: 48.5s +// result_is_ok_concurrent: true, calculation_time_concurrent: 2.1s +// result_is_ok_sequential: true, calculation_time_sequential: 15.2s // // cpp_bin_float: -// result_is_ok_concurrent: true, calculation_time_concurrent: 18.7s -// result_is_ok_sequential: true, calculation_time_sequential: 50.4s +// result_is_ok_concurrent: true, calculation_time_concurrent: 0.28s +// result_is_ok_sequential: true, calculation_time_sequential: 1.88s // // gmp_float: -// result_is_ok_concurrent: true, calculation_time_concurrent: 3.3s -// result_is_ok_sequential: true, calculation_time_sequential: 12.4s +// result_is_ok_concurrent: true, calculation_time_concurrent: 0.11s +// result_is_ok_sequential: true, calculation_time_sequential: 0.73s // // mpfr_float: -// result_is_ok_concurrent: true, calculation_time_concurrent: 0.6s -// result_is_ok_sequential: true, calculation_time_sequential: 1.9s +// result_is_ok_concurrent: true, calculation_time_concurrent: 0.05s +// result_is_ok_sequential: true, calculation_time_sequential: 0.24s #include #include +#include #include #include #include @@ -54,44 +58,46 @@ #include #include -#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT 101 -#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT 102 -#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT 103 -#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT 104 +#define BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT 101 +#define BOOST_MP_EXERCISE_THREADING_BACKEND_GMP_FLOAT 102 +#define BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT 103 +#define BOOST_MP_EXERCISE_THREADING_BACKEND_MPFR_FLOAT 104 -#if !defined(BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE) -#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT -//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT -//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT -//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT +#if !defined(BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE) +#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT +//#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT +//#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_GMP_FLOAT +//#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_MPFR_FLOAT #endif -#if (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT) +constexpr unsigned local_mp_digits { 301U }; + +#if (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT) #include -using big_float_type = boost::multiprecision::number, +using big_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; -#elif (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT) +#elif (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT) #include -using big_float_type = boost::multiprecision::number, +using big_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; -#elif (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT) +#elif (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_GMP_FLOAT) #include -using big_float_type = boost::multiprecision::number, +using big_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; -#elif (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT) +#elif (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_MPFR_FLOAT) #include -using big_float_type = boost::multiprecision::number, +using big_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; #else -#error BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE is undefined. +#error BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE is undefined. #endif namespace boost { namespace multiprecision { namespace exercise_threading { @@ -112,8 +118,8 @@ void parallel_for(index_type start, static const unsigned int number_of_threads_total = ((number_of_threads_hint == 0U) ? 4U : number_of_threads_hint); - // Use only 3/4 of the available cores. - static const unsigned int number_of_threads = number_of_threads_total - (number_of_threads_total / 8U); + // Use 7/8 of the available cores (leaving a core or two free on modern systems). + static const unsigned int number_of_threads = number_of_threads_total - ((number_of_threads_total + 4U) / 8U); std::cout << "Executing with " << number_of_threads << " threads" << std::endl; @@ -310,7 +316,7 @@ bool log_agm_concurrent(float& calculation_time) std::size_t concurrent_log_agm_count = 0U; - const std::clock_t start = std::clock(); + const auto start = std::chrono::high_resolution_clock::now(); boost::multiprecision::exercise_threading::detail::my_concurrency::parallel_for ( @@ -342,7 +348,7 @@ bool log_agm_concurrent(float& calculation_time) << log_results.size() << ". Total processed so far: " << std::fixed - << std::setprecision(1) + << std::setprecision(2) << (100.0F * float(concurrent_log_agm_count)) / float(log_results.size()) << "%." << "\r"; @@ -352,7 +358,9 @@ bool log_agm_concurrent(float& calculation_time) } ); - calculation_time = static_cast(std::clock() - start) / static_cast(CLOCKS_PER_SEC); + const auto stop = std::chrono::high_resolution_clock::now(); + + calculation_time = static_cast(std::chrono::duration_cast(stop - start).count()) / 1000.0F; std::cout << std::endl; @@ -384,7 +392,7 @@ bool log_agm_sequential(float& calculation_time) std::vector log_results(count); std::vector log_control(count); - const std::clock_t start = std::clock(); + const auto start = std::chrono::high_resolution_clock::now(); for(std::size_t i = 0U; i < log_results.size(); ++i) { @@ -404,14 +412,16 @@ bool log_agm_sequential(float& calculation_time) << log_results.size() << ". Total processed so far: " << std::fixed - << std::setprecision(1) + << std::setprecision(2) << (100.0F * float(sequential_log_agm_count)) / float(log_results.size()) << "%." << "\r"; } } - calculation_time = static_cast(std::clock() - start) / static_cast(CLOCKS_PER_SEC); + const auto stop = std::chrono::high_resolution_clock::now(); + + calculation_time = static_cast(std::chrono::duration_cast(stop - start).count()) / 1000.0F; std::cout << std::endl; @@ -442,31 +452,41 @@ int main() << " primes" << std::endl; - float calculation_time_concurrent; - const bool result_is_ok_concurrent = log_agm_concurrent(calculation_time_concurrent); + float calculation_time_concurrent { }; + float calculation_time_sequential { }; - float calculation_time_sequential; + const bool result_is_ok_concurrent = log_agm_concurrent(calculation_time_concurrent); const bool result_is_ok_sequential = log_agm_sequential(calculation_time_sequential); std::cout << std::endl; - std::cout << "result_is_ok_concurrent: " - << std::boolalpha - << result_is_ok_concurrent - << ", calculation_time_concurrent: " - << std::fixed - << std::setprecision(1) - << calculation_time_concurrent - << "s" - << std::endl; + { + std::stringstream strm { }; + + strm << "result_is_ok_concurrent: " + << std::boolalpha + << result_is_ok_concurrent + << ", calculation_time_concurrent: " + << std::fixed + << std::setprecision(2) + << calculation_time_concurrent + << "s"; + + std::cout << strm.str() << std::endl; + } - std::cout << "result_is_ok_sequential: " - << std::boolalpha - << result_is_ok_sequential - << ", calculation_time_sequential: " - << std::fixed - << std::setprecision(1) - << calculation_time_sequential - << "s" - << std::endl; + { + std::stringstream strm { }; + + strm << "result_is_ok_sequential: " + << std::boolalpha + << result_is_ok_sequential + << ", calculation_time_sequential: " + << std::fixed + << std::setprecision(2) + << calculation_time_sequential + << "s"; + + std::cout << strm.str() << std::endl; + } } diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index 84862d231..b78fc33f4 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -2531,26 +2531,53 @@ void cpp_dec_float::from_unsigned_long_long(c return; } - std::size_t i = static_cast(0u); + std::size_t index { static_cast(0u) }; - unsigned long long uu = u; + unsigned long long uu { u }; - std::uint32_t temp[(std::numeric_limits::digits10 / static_cast(cpp_dec_float_elem_digits10)) + 3] = {static_cast(0u)}; + constexpr std::size_t + local_storage_size + { + static_cast + ( + (std::numeric_limits::digits10 / static_cast(cpp_dec_float_elem_digits10)) + 3 + ) + }; + + using local_limb_type = std::uint32_t; + + using local_tmp_array_type = std::array; + + local_tmp_array_type temp { }; while (uu != static_cast(0u)) { - temp[i] = static_cast(uu % static_cast(cpp_dec_float_elem_mask)); - uu = static_cast(uu / static_cast(cpp_dec_float_elem_mask)); - ++i; + temp[index] = static_cast(uu % static_cast(cpp_dec_float_elem_mask)); + + uu = static_cast(uu / static_cast(cpp_dec_float_elem_mask)); + + ++index; } - if (i > static_cast(1u)) + if (index > static_cast(1u)) { - exp += static_cast((i - 1u) * static_cast(cpp_dec_float_elem_digits10)); + exp += static_cast((index - 1u) * static_cast(cpp_dec_float_elem_digits10)); } - std::reverse(temp, temp + i); - std::copy(temp, temp + (std::min)(i, static_cast(cpp_dec_float_elem_number)), data.begin()); + const std::size_t + copy_size + { + (std::min)(index, static_cast(cpp_dec_float_elem_number)) + }; + + using local_const_reverse_iterator_type = std::reverse_iterator; + + std::copy + ( + local_const_reverse_iterator_type(temp.data() + copy_size), + local_const_reverse_iterator_type(temp.data()), + data.begin() + ); } template From 01f516eed3afe1f0ac5681be5c8a824ab7d45218 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 21 Jul 2025 13:29:28 +0200 Subject: [PATCH 047/114] Improve an example and also cover lines --- example/exercise_threading_log_agm.cpp | 15 +++++-- .../boost/multiprecision/cpp_dec_float.hpp | 11 +++-- test/test_various_edges_more.cpp | 44 +++++++++++++++++++ 3 files changed, 62 insertions(+), 8 deletions(-) diff --git a/example/exercise_threading_log_agm.cpp b/example/exercise_threading_log_agm.cpp index 69d88fb5d..10a41f632 100644 --- a/example/exercise_threading_log_agm.cpp +++ b/example/exercise_threading_log_agm.cpp @@ -30,7 +30,7 @@ // // cpp_dec_float: // result_is_ok_concurrent: true, calculation_time_concurrent: 2.1s -// result_is_ok_sequential: true, calculation_time_sequential: 15.2s +// result_is_ok_sequential: true, calculation_time_sequential: 14.7s // // cpp_bin_float: // result_is_ok_concurrent: true, calculation_time_concurrent: 0.28s @@ -52,6 +52,7 @@ #include #include #include +#include #include #include @@ -70,7 +71,7 @@ //#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_MPFR_FLOAT #endif -constexpr unsigned local_mp_digits { 301U }; +constexpr unsigned local_mp_digits { 101U }; #if (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT) #include @@ -379,7 +380,10 @@ bool log_agm_concurrent(float& calculation_time) result_is_ok &= (close_fraction < tol); } - std::cout << std::boolalpha << result_is_ok << std::endl; + std::stringstream strm { }; + strm << std::boolalpha << result_is_ok; + + std::cout << strm.str() << std::endl; return result_is_ok; } @@ -440,7 +444,10 @@ bool log_agm_sequential(float& calculation_time) result_is_ok &= (close_fraction < tol); } - std::cout << std::boolalpha << result_is_ok << std::endl; + std::stringstream strm { }; + strm << std::boolalpha << result_is_ok; + + std::cout << strm.str() << std::endl; return result_is_ok; } diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index b78fc33f4..e854af78f 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -472,11 +472,14 @@ class cpp_dec_float // LCOV_EXCL_LINE This causes a false negative on lcov cover exponent_type order() const { - const bool bo_order_is_zero = ((!(isfinite)()) || (data[0] == static_cast(0u))); - - exponent_type prefix = limb_order(data[static_cast(UINT8_C(0))]); + const bool + bo_order_is_zero + { + ((!(isfinite)()) || (data[0] == static_cast(0u))) + }; - return (bo_order_is_zero ? static_cast(0) : static_cast(exp + prefix)); + return (bo_order_is_zero ? static_cast(0) + : static_cast(exp + limb_order(data[static_cast(UINT8_C(0))]))); } #ifndef BOOST_MP_STANDALONE diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 222b9e4f6..d8ff84aba 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -622,6 +622,50 @@ namespace local } } + BOOST_IF_CONSTEXPR((std::numeric_limits::digits >= 24) && std::numeric_limits::is_specialized) + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + // This test is specifically designed to pick up hard-to-reach lines + // in cpp_dec_float. Notice how the printed string is expected to have + // (or not have) rounding at the 8th fixed-point digit. + + // N[1 + 1/2^4 + 1/2^5 + 1/2^7 + 1/2^9, 20] + const float flt_builtin { 1.1035156250000000000F }; + + const float_type delta = std::numeric_limits::epsilon() * dis(gen) * static_cast(index + 1U); + + const float_type flt_val_base { flt_builtin }; + + const float_type flt_val_close_upper { flt_builtin + delta }; + const float_type flt_val_close_lower { flt_builtin - delta }; + + { + std::stringstream strm { }; + + strm << std::fixed << std::setprecision(std::streamsize { INT8_C(8) }) << flt_val_base; + + BOOST_TEST(strm.str() == "1.10351562"); + } + + { + std::stringstream strm { }; + + strm << std::fixed << std::setprecision(std::streamsize { INT8_C(8) }) << flt_val_close_upper; + + BOOST_TEST(strm.str() > "1.10351562"); + } + + { + std::stringstream strm { }; + + strm << std::fixed << std::setprecision(std::streamsize { INT8_C(8) }) << flt_val_close_lower; + + BOOST_TEST(strm.str() == "1.10351562"); + } + } + } + return result_is_ok; } From 76224e2466445c7d98fe5a479e6dca6f56aac123 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 21 Jul 2025 15:00:23 +0200 Subject: [PATCH 048/114] Fix a typo and get even more cover dec-float --- example/exercise_threading_log_agm.cpp | 2 +- .../boost/multiprecision/cpp_dec_float.hpp | 27 +++++++++++++------ 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/example/exercise_threading_log_agm.cpp b/example/exercise_threading_log_agm.cpp index 10a41f632..0a9625b54 100644 --- a/example/exercise_threading_log_agm.cpp +++ b/example/exercise_threading_log_agm.cpp @@ -71,7 +71,7 @@ //#define BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE BOOST_MP_EXERCISE_THREADING_BACKEND_MPFR_FLOAT #endif -constexpr unsigned local_mp_digits { 101U }; +constexpr unsigned local_mp_digits { 301U }; #if (BOOST_MP_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MP_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT) #include diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index e854af78f..e9ae39f58 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1246,7 +1246,11 @@ cpp_dec_float& cpp_dec_float(1.0 / dd, -ne)); // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration @@ -1316,7 +1320,10 @@ cpp_dec_float& cpp_dec_float(sqd, static_cast(ne / static_cast(2))); @@ -1535,7 +1542,8 @@ void cpp_dec_float::extract_parts(double& man mantissa /= p10; // Extract the rest of the mantissa piecewise from the limbs. - // This loop does not round. + // This loop does not round. For finite values, the absolute + // value of the mantissa is scaled and between 1 and 10. auto itr_data = data.cbegin() + static_cast(UINT8_C(1)); @@ -2423,11 +2431,14 @@ cpp_dec_float::cpp_dec_float(const double man { exponent_type exp10_val { exp10 }; - while (d_mant > 10.0) - { - d_mant /= 10.0; - ++exp10_val; - } + // This subroutine is used after a call to extract_parts(). + // The corresponding scaling loop for (d_mant > 10.0) is not + // needed here since extract_parts() returns a mantissa value + // between 1 and 10. The loop for (d_mant < 1.0) is needed + // since the initial guess of the square root in tghe subroutine + // calculate_root() might have been divided by 10 in order + // to obtain an exponent value that is a multiple of 2. + while (d_mant < 1.0) { d_mant *= 10.0; From ccb113d75c2aa221820fc2efc2e25c249813a43d Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 21 Jul 2025 20:42:31 +0200 Subject: [PATCH 049/114] Add more tests and also get more TBDs --- test/test_various_edges_more.cpp | 145 ++++++++++++++++++++++++++++--- 1 file changed, 133 insertions(+), 12 deletions(-) diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index d8ff84aba..9806386f3 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -5,6 +5,10 @@ // Some parts of this test file have been taken from the Boost.Decimal project. +#define TEST_CPP_BIN_FLOAT +#define TEST_CPP_DEC_FLOAT +#define TEST_CPP_DOUBLE_FLOAT + #include #include #include @@ -30,6 +34,9 @@ template auto my_one () noexcept -> FloatType&; template auto my_inf () noexcept -> FloatType&; template auto my_nan () noexcept -> FloatType&; +template auto my_generator_overflow() noexcept -> FloatType; +template auto my_generator_underflow() noexcept -> FloatType; + namespace local { template::value) { for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(64)); ++index) { @@ -266,7 +275,7 @@ namespace local (str_n128 == str_ctrl) && ( (!is_neg) ? (val_n128 >= static_cast((std::numeric_limits::max)())) - : (val_n128 <= static_cast((std::numeric_limits::max)())) + : (val_n128 <= static_cast(std::numeric_limits::lowest())) ) ); @@ -490,6 +499,8 @@ namespace local result_is_ok = (result_unf_is_ok && result_is_ok); } + // TBD: See open issues for reminder to get this working in cpp_double_fp_backend. + BOOST_IF_CONSTEXPR(!::has_poor_exp_range_or_precision_support::value) { using std::ldexp; @@ -513,6 +524,8 @@ namespace local result_is_ok = (result_ovf_is_ok && result_is_ok); } + // TBD: See open issues for reminder to get this working in cpp_double_fp_backend. + BOOST_IF_CONSTEXPR(!::has_poor_exp_range_or_precision_support::value) { using std::ldexp; @@ -669,11 +682,52 @@ namespace local return result_is_ok; } + template + bool test_edges_ovf_und() + { + using float_type = FloatType; + + std::mt19937_64 gen { time_point() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.01F), + static_cast(1.04F) + }; + + bool result_is_ok { true }; + + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + const float_type flt_ovf = ::my_generator_overflow() * dis(gen); + const float_type flt_und = ::my_generator_underflow() * dis(gen); + + const bool + result_ovf_und_is_ok + { + ((boost::multiprecision::isinf)(flt_ovf) && ((boost::multiprecision::fpclassify)(flt_und) == FP_ZERO)) + }; + + BOOST_TEST(result_ovf_und_is_ok); + + result_is_ok = (result_ovf_und_is_ok && result_is_ok); + } + } + + return result_is_ok; + } + template bool test_edges_trig() { using float_type = FloatType; + std::mt19937_64 gen { time_point() }; + auto dis = std::uniform_real_distribution { @@ -689,8 +743,6 @@ namespace local BOOST_IF_CONSTEXPR(std::numeric_limits::has_quiet_NaN) { - std::mt19937_64 gen { UINT64_C(0xF00DCAFEDEADBEEF) }; - for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(8)); ++index) { static_cast(index); @@ -875,27 +927,40 @@ namespace local auto main() -> int { - using bin_float_backend_type = boost::multiprecision::cpp_bin_float<50>; + { using dec_float_backend_type = boost::multiprecision::cpp_dec_float<50>; - - using bin_float_type = boost::multiprecision::number; using dec_float_type = boost::multiprecision::number; + std::cout << "Testing type: " << typeid(dec_float_type).name() << std::endl; + + static_cast(local::test_edges()); + static_cast(local::test_edges_ovf_und()); + static_cast(local::test_edges_trig()); + local::test_cpp_dec_float_rd_ovf_unf(); + local::test_convert_and_back(0.0F); + local::test_cpp_dec_float_frexp_edge(); + } + { + using bin_float_backend_type = boost::multiprecision::cpp_bin_float<50>; + using bin_float_type = boost::multiprecision::number; + std::cout << "Testing type: " << typeid(bin_float_type).name() << std::endl; static_cast(local::test_edges()); + // TBD: This seemingly trivial test fails for cpp_bin_float. + //static_cast(local::test_edges_ovf_und()); static_cast(local::test_edges_trig()); } { - std::cout << "Testing type: " << typeid(dec_float_type).name() << std::endl; + using double_float_type = boost::multiprecision::cpp_double_double; - static_cast(local::test_edges()); - static_cast(local::test_edges_trig()); - local::test_cpp_dec_float_rd_ovf_unf(); - local::test_convert_and_back(0.0F); - local::test_cpp_dec_float_frexp_edge(); + std::cout << "Testing type: " << typeid(double_float_type).name() << std::endl; + + static_cast(local::test_edges()); + static_cast(local::test_edges_ovf_und()); + static_cast(local::test_edges_trig()); } { @@ -917,6 +982,62 @@ template auto my_one () noexcept -> FloatType& { using float template auto my_inf () noexcept -> FloatType& { using float_type = FloatType; static float_type val_inf { std::numeric_limits::infinity() }; return val_inf; } template auto my_nan () noexcept -> FloatType& { using float_type = FloatType; static float_type val_nan { std::numeric_limits::quiet_NaN() }; return val_nan; } +template +static auto + overflow_expval_maker + { + []() + { + std::stringstream strm { }; + + using float_type = FloatType; + + strm << std::numeric_limits::max_exponent10 + 4; + + return strm.str(); + } + }; + +template +static auto + underflow_expval_maker + { + []() + { + std::stringstream strm { }; + + using float_type = FloatType; + + strm << std::numeric_limits::min_exponent10 - 4; + + return strm.str(); + } + }; + +template +auto my_generator_overflow() noexcept -> FloatType +{ + using float_type = FloatType; + + const float_type flt_ovf("1.23E" + overflow_expval_maker()); + + const float_type result(flt_ovf); + + return result; +} + +template +auto my_generator_underflow() noexcept -> FloatType +{ + using float_type = FloatType; + + float_type flt_und("1.23E" + underflow_expval_maker()); + + const float_type result(flt_und); + + return result; +} + #if (defined(__clang__) || defined(__GNUC__)) # pragma GCC diagnostic pop #endif From eaab3bb4323e6176a377583fd178883bc67ca44e Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 15 Aug 2025 18:20:54 +0200 Subject: [PATCH 050/114] Docs style and typos and more syntax --- doc/tutorial_cpp_double_fp_backend.qbk | 25 ++++++++++--------- .../boost/multiprecision/cpp_double_fp.hpp | 15 +++++------ 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/doc/tutorial_cpp_double_fp_backend.qbk b/doc/tutorial_cpp_double_fp_backend.qbk index e8ea09882..006f720b8 100644 --- a/doc/tutorial_cpp_double_fp_backend.qbk +++ b/doc/tutorial_cpp_double_fp_backend.qbk @@ -24,26 +24,27 @@ } } // namespaces The `cpp_double_fp_backend` back-end is the sum of two IEEE floating-point numbers -combined to create a type having rougly twice the composite width of one of its parts. +combined to create a type having a composite width rougly twice that as one of its parts. The `cpp_double_fp_backend` back-end is used in conjunction with `number` and acts as an entirely C++ header only floating-point number type. The implementation relies on double-word arithmetic which is a technique used to represent a real number as the sum of two floating-point numbers. -Other commonly used names for this include `double-double` of `double-word` arithmetic. +Other commonly used names for this include `double-double` or `double-word` arithmetic. The `cpp_double_fp_backend` types have fixed width and do not allocate. -The type `cpp_double_double`, for instance, (composed of two double-precision IEEE floating-point numebers) -has (on most common systems) 106 binary digits of precision and approximately +The type `cpp_double_double`, for instance, is composed of two built-in `double` components. +On most common systems, built-in `double` is a double-precision IEEE floating-point number. +This results in a `cpp_double_double` that has 106 binary digits and approximately 32 decimal digits of precision. -The exponent ranges of the types are slightly limited (on the negative side) compared to those of the composite type. -Consider again the type `cpp_double_double`, composed of two double-precision IEEE double-precision +The exponent ranges of the types are slightly limited (on the negative side) compared to those of the composing type. +Consider again the type `cpp_double_double`, which is built from two double-precision IEEE double-precision floating-point numebers. On common systems, this type has a maximum decimal exponent of 308 -(as does a single double-precision floating point number). The negative minimum exponent, however, -is about -291, which is less range than the -307 from standalone double. The reason for -the limitation is because the composite lower-limb has lower value than its upper limb and would -underflow or become subnormal if the upper limb had its usual minimum value. +(the same as one single double-precision floating point number). The negative minimum exponent, however, +is about -291, which is less range than -307 from standalone double. The reason for +the limitation is because the composite lower-limb has lower value than its upper limb. +The composite type would easily underflow or become subnormal if the upper limb had its usual minimum value. There is full standard library and `std::numeric_limits` support available for this type. @@ -66,7 +67,7 @@ Things you should know when using the `cpp_double_fp_backend` types: * Although the types are created from two individual IEEE floating-point components, they specifically and clearly are not IEEE types in their composite forms. * As a result these types can behave subtly differently from IEEE floating-point types. -* The types can not be used with compiler variations of _fast_-_math_ (i.e., `-ffast-math` on GCC can not be used and `/fp:precise` is mandatory on MSVC compilers). This is because the algorithms (particularly those for addition, subtraction, multiplication and square root) rely on precise floating-point rouunding. +* The types can not be used with compiler variations of _fast_-_math_ (i.e., `-ffast-math` on GCC can not be used and `/fp:precise` is mandatory on MSVC compilers). This is because the algorithms (particularly those for addition, subtraction, multiplication and square root) rely on precise floating-point rounding. * The composite types are not as precise as their constituents. For information on error-bounds, see Joldes et al. in the references below. * There are `std::numeric_limits` specializations for these types. * Large parts (but not all) of the `cpp_double_fp_backend` implementation are `constexpr`. Future evolution is anticipated to make this library entirely `constexpr`. @@ -79,6 +80,6 @@ and more. These include the following: * V. Shoup, the class `quad_float` in the NTL number-theory library [@https://libntl.org]. * Yozo Hida, X. Li, and D. H. Bailey, Quad-Double Arithmetic: Algorithms, Implementation, and Application, Lawrence Berkeley National Laboratory Technical Report LBNL-46996 (2000). Also Y. Hida et al., Library for double-double and quad-double arithmetic [@https://web.mit.edu/tabbott/Public/quaddouble-debian/qd-2.3.4-old/docs/qd.pdf]. * Mioara Maria Joldes, Jean-Michel Muller, Valentina Popescu. Tight and rigourous error bounds for basic building blocks of double-word arithmetic. ACM Transactions on Mathematical Software, 2017, 44 (2), pp. 1 - 27. ff10.1145/3121432ff. ffhal-01351529v3f. -* The foundational `cpp_double_fp_backend` draft was originally created by Fahad Syed in BoostGSoC2021 _multiprecision_ [@https://github.com/BoostGSoC21/multiprecision]. +* The foundational `cpp_double_fp_backend` draft was originally created by Fahad Syed in Boost GSoC2021 multiprecision project. Its source code can be found at [@https://github.com/BoostGSoC21/multiprecision]. [endsect] diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index f88f4fbda..befcd5f43 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -166,12 +166,13 @@ namespace backends { // A cpp_double_fp_backend is represented by an unevaluated sum of two // floating-point units, a0 and a1, which satisfy |a1| <= (1 / 2) * ulp(a0). // The type of the floating-point constituents should adhere to IEEE754. -// This class has been tested with floats having single-precision (4 byte), -// double-precision (8 byte) and quad precision (16 byte, such as GCC's __float128). // Although the constituent parts (a0 and a1) satisfy |a1| <= (1 / 2) * ulp(a0), // the composite type does not adhere to these strict error bounds. Its error // bounds are larger. +// This class has been tested with floats having single-precision (4 byte), +// double-precision (8 byte) and quad precision (16 byte, such as GCC's __float128). + template class cpp_double_fp_backend { @@ -1461,7 +1462,7 @@ constexpr auto eval_sqrt(cpp_double_fp_backend& result, const }; result.rep().first = c + cc; - result.rep().second = local_float_type { c - result.rep().first } + cc; + result.rep().second = local_float_type { c - result.my_first() } + cc; } template @@ -2663,16 +2664,16 @@ struct precision; - using digits_2 = digits2; + using digits2_type = digits2; public: using precision_type = typename Policy::precision_type; using type = typename std::conditional< - ((digits_2::value <= precision_type::value) || (precision_type::value <= 0)), - digits_2, // Default case: Full precision for RealType. - precision_type>::type; // User customized precision. + ((digits2_type::value <= precision_type::value) || (precision_type::value <= 0)), + digits2_type, // This is the default case: Use full precision for RealType. + precision_type>::type; // Here we find (and use) user-customized precision. }; } } } // namespace boost::math::policies From c841339330f880d8c868ac7ae1be88e7eb27cd3c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 16 Aug 2025 07:18:30 +0200 Subject: [PATCH 051/114] Update docs again and re-run CI --- doc/tutorial_cpp_double_fp_backend.qbk | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/tutorial_cpp_double_fp_backend.qbk b/doc/tutorial_cpp_double_fp_backend.qbk index 006f720b8..b564e7f1c 100644 --- a/doc/tutorial_cpp_double_fp_backend.qbk +++ b/doc/tutorial_cpp_double_fp_backend.qbk @@ -56,8 +56,8 @@ also in strict ANSI mode. Run-time performance is a top-level requirement for the `cpp_double_fp_backend` types. The types still do, however, support infinities, NaNs and (of course) zeros. -Signed negative zero, however, is not supported (in favor of efficiency) -and all zeros are treated as positive. +Signed negative zero, however, is not supported (in favor of efficiency). +All zeros are treated as positive. The `cpp_double_fp_backend` types interoperate with Boost.Math and Boost.Math.Constants. This offers the wealth of Boost-related mathematical tools instantiated with From 8dfd6f35c7f9caf4ef6d607fe18c436957b9db3c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 16 Aug 2025 14:25:25 +0200 Subject: [PATCH 052/114] Add a few more tests --- .../boost/multiprecision/cpp_bin_float.hpp | 4 +-- test/test_various_edges_more.cpp | 34 ++++++++++++++++--- 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/include/boost/multiprecision/cpp_bin_float.hpp b/include/boost/multiprecision/cpp_bin_float.hpp index 1472352bb..13869289d 100644 --- a/include/boost/multiprecision/cpp_bin_float.hpp +++ b/include/boost/multiprecision/cpp_bin_float.hpp @@ -1255,7 +1255,7 @@ inline void eval_divide(cpp_bin_float::va // // q * v + r = u // - // and hense: + // and hence: // // q + r/v = u/v // diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 9806386f3..2e4c0b7ec 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -594,6 +594,30 @@ namespace local } } + { + const float_type flt_nan { ::my_nan() }; + const float_type flt_inf { ::my_inf() }; + + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) + { + static_cast(index); + + flt_nan * dis(gen); + flt_inf * dis(gen); + + const float_type finite { float_type { 123 } / 100 }; + + const float_type eq_nan = finite + flt_nan; + const float_type eq_inf = finite + flt_inf; + + const bool result_nan_is_ok = (boost::multiprecision::isnan)(eq_nan); + const bool result_inf_is_ok = (boost::multiprecision::isinf)(eq_inf); + + BOOST_TEST(result_nan_is_ok); + BOOST_TEST(result_inf_is_ok); + } + } + { for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(16)); ++index) { @@ -876,10 +900,10 @@ namespace local } } - template - auto test_cpp_dec_float_frexp_edge() -> void + template + auto test_frexp_edge() -> void { - using float_type = CppDecFloatType; + using float_type = AnyFloatType; using float_backend_ctrl_type = boost::multiprecision::cpp_bin_float<50, boost::multiprecision::digit_base_10, void, std::int32_t>; @@ -938,7 +962,7 @@ auto main() -> int static_cast(local::test_edges_trig()); local::test_cpp_dec_float_rd_ovf_unf(); local::test_convert_and_back(0.0F); - local::test_cpp_dec_float_frexp_edge(); + local::test_frexp_edge(); } { @@ -951,6 +975,7 @@ auto main() -> int // TBD: This seemingly trivial test fails for cpp_bin_float. //static_cast(local::test_edges_ovf_und()); static_cast(local::test_edges_trig()); + local::test_frexp_edge(); } { @@ -961,6 +986,7 @@ auto main() -> int static_cast(local::test_edges()); static_cast(local::test_edges_ovf_und()); static_cast(local::test_edges_trig()); + local::test_frexp_edge(); } { From 55bf06962149d1b150fe9eb42d6366f672251b9d Mon Sep 17 00:00:00 2001 From: ivanpanch Date: Mon, 18 Aug 2025 13:14:39 +0200 Subject: [PATCH 053/114] Fix mistakes (#729) * Update Jamfile.v2 * Update introduction.qbk * Update tutorial.qbk * Update tutorial_cpp_int.qbk * Update tutorial_gmp_int.qbk * Update tutorial_tommath.qbk * Update integer_examples.cpp * Update tutorial_cpp_bin_float.qbk * Update tutorial_cpp_dec_float.qbk * Update tutorial_gmp_float.qbk * Update tutorial_mpfr_float.qbk * Update tutorial_float128.qbk * Update tutorial_float_builtin_ctor.qbk * Update big_seventh.cpp * Update tutorial_float_eg.qbk * Update floating_point_examples.cpp * Update mpfr_precision.cpp * Update gauss_laguerre_quadrature.cpp * Update tutorial_interval_mpfi.qbk * Update tutorial_cpp_complex.qbk * Update tutorial_mpc_complex.qbk * Update tutorial_float128_complex.qbk * Update tutorial_complex_adaptor.qbk * Update tutorial_rational.qbk * Update tutorial_tommath_rational.qbk * Update tutorial_logged_adaptor.qbk * Update tutorial_debug_adaptor.qbk * Update tutorial_visualizers.qbk * Update tutorial_fwd.qbk * Update tutorial_conversions.qbk * Update tutorial_random.qbk * Update random_snips.cpp * Update tutorial_constexpr.qbk * Update tutorial_import_export.qbk * Update cpp_int_import_export.cpp * Update tutorial_mixed_precision.qbk * Update tutorial_variable_precision.qbk * Update scoped_precision_example.cpp * Update tutorial_numeric_limits.qbk * Update tutorial_numeric_limits.qbk * Update numeric_limits_snips.cpp * Update numeric_limits_snips.cpp * Update tutorial_numeric_limits.qbk * Update numeric_limits_snips.cpp * Update numeric_limits_snips.cpp * Update tutorial_io.qbk * Update reference_number.qbk * Update reference_cpp_bin_float.qbk * Update reference_cpp_double_fp_backend.qbk * Update reference_internal_support.qbk * Update reference_backend_requirements.qbk * Update performance.qbk * Update performance_overhead.qbk * Update performance_real_world.qbk * Update performance_integer_real_world.qbk * Update performance_rational_real_world.qbk * Update reference_number.qbk * Update tutorial_numeric_limits.qbk * Update reference_backend_requirements.qbk --- config/Jamfile.v2 | 2 +- doc/introduction.qbk | 30 ++--- doc/performance.qbk | 6 +- doc/performance_integer_real_world.qbk | 44 ++++---- doc/performance_overhead.qbk | 2 +- doc/performance_rational_real_world.qbk | 2 +- doc/performance_real_world.qbk | 12 +- doc/reference_backend_requirements.qbk | 142 ++++++++++++------------ doc/reference_cpp_bin_float.qbk | 4 +- doc/reference_cpp_double_fp_backend.qbk | 2 +- doc/reference_internal_support.qbk | 2 +- doc/reference_number.qbk | 10 +- doc/tutorial.qbk | 4 +- doc/tutorial_complex_adaptor.qbk | 2 +- doc/tutorial_constexpr.qbk | 14 +-- doc/tutorial_conversions.qbk | 14 +-- doc/tutorial_cpp_bin_float.qbk | 8 +- doc/tutorial_cpp_complex.qbk | 6 +- doc/tutorial_cpp_dec_float.qbk | 2 +- doc/tutorial_cpp_int.qbk | 8 +- doc/tutorial_debug_adaptor.qbk | 2 +- doc/tutorial_float128.qbk | 4 +- doc/tutorial_float128_complex.qbk | 2 +- doc/tutorial_float_builtin_ctor.qbk | 4 +- doc/tutorial_float_eg.qbk | 4 +- doc/tutorial_fwd.qbk | 2 +- doc/tutorial_gmp_float.qbk | 8 +- doc/tutorial_gmp_int.qbk | 2 +- doc/tutorial_import_export.qbk | 2 +- doc/tutorial_interval_mpfi.qbk | 6 +- doc/tutorial_io.qbk | 4 +- doc/tutorial_logged_adaptor.qbk | 2 +- doc/tutorial_mixed_precision.qbk | 10 +- doc/tutorial_mpc_complex.qbk | 2 +- doc/tutorial_mpfr_float.qbk | 2 +- doc/tutorial_numeric_limits.qbk | 32 +++--- doc/tutorial_random.qbk | 8 +- doc/tutorial_rational.qbk | 2 +- doc/tutorial_tommath.qbk | 2 +- doc/tutorial_tommath_rational.qbk | 6 +- doc/tutorial_variable_precision.qbk | 14 +-- doc/tutorial_visualizers.qbk | 2 +- example/big_seventh.cpp | 4 +- example/cpp_int_import_export.cpp | 2 +- example/floating_point_examples.cpp | 4 +- example/gauss_laguerre_quadrature.cpp | 2 +- example/integer_examples.cpp | 4 +- example/mpfr_precision.cpp | 14 +-- example/numeric_limits_snips.cpp | 8 +- example/random_snips.cpp | 4 +- example/scoped_precision_example.cpp | 12 +- 51 files changed, 246 insertions(+), 246 deletions(-) diff --git a/config/Jamfile.v2 b/config/Jamfile.v2 index 6f6491050..745467733 100644 --- a/config/Jamfile.v2 +++ b/config/Jamfile.v2 @@ -1,7 +1,7 @@ # copyright John Maddock 2008 # 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. +# http://www.boost.org/LICENSE_1_0.txt) import-search /boost/config/checks ; diff --git a/doc/introduction.qbk b/doc/introduction.qbk index b7e68b400..1243256bf 100644 --- a/doc/introduction.qbk +++ b/doc/introduction.qbk @@ -60,7 +60,7 @@ but a header-only Boost license version is always available (if somewhat slower) Should you just wish to 'cut to the chase' just to get bigger integers and/or bigger and more precise reals as simply and portably as possible, close to 'drop-in' replacements for the __fundamental_type analogs, -then use a fully Boost-licensed number type, and skip to one of more of : +then use a fully Boost-licensed number type, and skip to one or more of: * __cpp_int for multiprecision integers, * __cpp_rational for rational types, @@ -133,8 +133,8 @@ Conversions are also allowed: However conversions that are inherently lossy are either declared explicit or else forbidden altogether: - d = 3.14; // Error implicit conversion from double not allowed. - d = static_cast(3.14); // OK explicit construction is allowed + d = 3.14; // Error, implicit conversion from double not allowed. + d = static_cast(3.14); // OK, explicit construction is allowed Mixed arithmetic will fail if the conversion is either ambiguous or explicit: @@ -195,9 +195,9 @@ of references to the arguments of the function, plus some compile-time informati is. The great advantage of this method is the ['elimination of temporaries]: for example, the "naive" implementation -of `operator*` above, requires one temporary for computing the result, and at least another one to return it. It's true +of `operator*` above requires one temporary for computing the result, and at least another one to return it. It's true that sometimes this overhead can be reduced by using move-semantics, but it can't be eliminated completely. For example, -lets suppose we're evaluating a polynomial via Horner's method, something like this: +let's suppose we're evaluating a polynomial via Horner's method, something like this: T a[7] = { /* some values */ }; //.... @@ -206,7 +206,7 @@ lets suppose we're evaluating a polynomial via Horner's method, something like t If type `T` is a `number`, then this expression is evaluated ['without creating a single temporary value]. In contrast, if we were using the [mpfr_class] C++ wrapper for [mpfr] - then this expression would result in no less than 11 temporaries (this is true even though [mpfr_class] does use expression templates to reduce the number of temporaries somewhat). Had -we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less that 24 temporaries +we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less than 24 temporaries are created for this simple expression (note - we actually measure the number of memory allocations performed rather than the number of temporaries directly, note also that the [mpf_class] wrapper supplied with GMP-5.1 or later reduces the number of temporaries to pretty much zero). Note that if we compile with expression templates disabled and rvalue-reference support @@ -247,7 +247,7 @@ is created in this case. Given the comments above, you might be forgiven for thinking that expression-templates are some kind of universal-panacea: sadly though, all tricks like this have their downsides. For one thing, expression template libraries -like this one, tend to be slower to compile than their simpler cousins, they're also harder to debug +like this one tend to be slower to compile than their simpler cousins, they're also harder to debug (should you actually want to step through our code!), and rely on compiler optimizations being turned on to give really good performance. Also, since the return type from expressions involving `number`s is an "unmentionable implementation detail", you have to be careful to cast the result of an expression @@ -256,23 +256,23 @@ to the actual number type when passing an expression to a template function. Fo template void my_proc(const T&); -Then calling: +Then calling my_proc(a+b); -Will very likely result in obscure error messages inside the body of `my_proc` - since we've passed it +will very likely result in obscure error messages inside the body of `my_proc` - since we've passed it an expression template type, and not a number type. Instead we probably need: my_proc(my_number_type(a+b)); Having said that, these situations don't occur that often - or indeed not at all for non-template functions. In addition, all the functions in the Boost.Math library will automatically convert expression-template arguments -to the underlying number type without you having to do anything, so: +to the underlying number type without you having to do anything, so mpfr_float_100 a(20), delta(0.125); boost::math::gamma_p(a, a + delta); -Will work just fine, with the `a + delta` expression template argument getting converted to an `mpfr_float_100` +will work just fine, with the `a + delta` expression template argument getting converted to an `mpfr_float_100` internally by the Boost.Math library. [caution In C++11 you should never store an expression template using: @@ -299,7 +299,7 @@ dramatic as the reduction in number of temporaries would suggest. For example, we see the following typical results for polynomial execution: [table Evaluation of Order 6 Polynomial. -[[Library] [Relative Time] [Relative number of memory allocations]] +[[Library] [Relative Time] [Relative Number of Memory Allocations]] [[number] [1.0 (0.00957s)] [1.0 (2996 total)]] [[[mpfr_class]] [1.1 (0.0102s)] [4.3 (12976 total)]] [[[mpreal]] [1.6 (0.0151s)] [9.3 (27947 total)]] @@ -311,13 +311,13 @@ a number of reasons for this: * The cost of extended-precision multiplication and division is so great, that the times taken for these tend to swamp everything else. * The cost of an in-place multiplication (using `operator*=`) tends to be more than an out-of-place -`operator*` (typically `operator *=` has to create a temporary workspace to carry out the multiplication, where -as `operator*` can use the target variable as workspace). Since the expression templates carry out their +`operator*` (typically `operator *=` has to create a temporary workspace to carry out the multiplication, +whereas `operator*` can use the target variable as workspace). Since the expression templates carry out their magic by converting out-of-place operators to in-place ones, we necessarily take this hit. Even so the transformation is more efficient than creating the extra temporary variable, just not by as much as one would hope. -Finally, note that `number` takes a second template argument, which, when set to `et_off` disables all +Finally, note that `number` takes a second template argument, which, when set to `et_off`, disables all the expression template machinery. The result is much faster to compile, but slower at runtime. We'll conclude this section by providing some more performance comparisons between these three libraries, diff --git a/doc/performance.qbk b/doc/performance.qbk index 7856ed6d7..20cbba897 100644 --- a/doc/performance.qbk +++ b/doc/performance.qbk @@ -5,7 +5,7 @@ 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). + http://www.boost.org/LICENSE_1_0.txt.) ] [section:perf Performance Comparison] @@ -30,7 +30,7 @@ share similar relative performances. The backends which effectively wrap GMP/MPIR and MPFR retain the superior performance of the low-level big-number engines. -When these are used (in association with at least some level of optmization) +When these are used (in association with at least some level of optimization) they achieve and retain the expected low-level performances. At low digit counts, however, it is noted that the performances of __cpp_int, @@ -47,7 +47,7 @@ the performances of the Boost-licensed, self-written backends. At around a few hundred to several thousands of digits, factors of about two through five are observed, whereby GMP/MPIR-based calculations are (performance-wise) -supreior ones. +superior ones. At a few thousand decimal digits, the upper end of the Boost backends is reached. At the moment, diff --git a/doc/performance_integer_real_world.qbk b/doc/performance_integer_real_world.qbk index f989a0c3e..36751081b 100644 --- a/doc/performance_integer_real_world.qbk +++ b/doc/performance_integer_real_world.qbk @@ -18,16 +18,16 @@ type which was custom written for this specific task: [table [[Integer Type][Relative Performance (Actual time in parenthesis)]] -[[checked_int1024_t][1.53714(0.0415328s)]] -[[checked_int256_t][1.20715(0.0326167s)]] -[[checked_int512_t][1.2587(0.0340095s)]] -[[cpp_int][1.80575(0.0487904s)]] -[[extended_int][1.35652(0.0366527s)]] -[[int1024_t][1.36237(0.0368107s)]] -[[int256_t][1(0.0270196s)]] -[[int512_t][1.0779(0.0291243s)]] -[[mpz_int][3.83495(0.103619s)]] -[[tom_int][41.6378(1.12504s)]] +[[checked_int1024_t][1.53714 (0.0415328s)]] +[[checked_int256_t][1.20715 (0.0326167s)]] +[[checked_int512_t][1.2587 (0.0340095s)]] +[[cpp_int][1.80575 (0.0487904s)]] +[[extended_int][1.35652 (0.0366527s)]] +[[int1024_t][1.36237 (0.0368107s)]] +[[int256_t][1 (0.0270196s)]] +[[int512_t][1.0779 (0.0291243s)]] +[[mpz_int][3.83495 (0.103619s)]] +[[tom_int][41.6378 (1.12504s)]] ] Note how for this use case, any dynamic allocation is a performance killer. @@ -38,18 +38,18 @@ since that is the rate limiting step: [table [[Integer Type][Relative Performance (Actual time in parenthesis)]] -[[checked_uint1024_t][9.52301(0.0422246s)]] -[[cpp_int][11.2194(0.0497465s)]] -[[cpp_int (1024-bit cache)][10.7941(0.0478607s)]] -[[cpp_int (128-bit cache)][11.0637(0.0490558s)]] -[[cpp_int (256-bit cache)][11.5069(0.0510209s)]] -[[cpp_int (512-bit cache)][10.3303(0.0458041s)]] -[[cpp_int (no Expression templates)][16.1792(0.0717379s)]] -[[mpz_int][1.05106(0.00466034s)]] -[[mpz_int (no Expression templates)][1(0.00443395s)]] -[[tom_int][5.10595(0.0226395s)]] -[[tom_int (no Expression templates)][61.9684(0.274765s)]] -[[uint1024_t][9.32113(0.0413295s)]] +[[checked_uint1024_t][9.52301 (0.0422246s)]] +[[cpp_int][11.2194 (0.0497465s)]] +[[cpp_int (1024-bit cache)][10.7941 (0.0478607s)]] +[[cpp_int (128-bit cache)][11.0637 (0.0490558s)]] +[[cpp_int (256-bit cache)][11.5069 (0.0510209s)]] +[[cpp_int (512-bit cache)][10.3303 (0.0458041s)]] +[[cpp_int (no Expression templates)][16.1792 (0.0717379s)]] +[[mpz_int][1.05106 (0.00466034s)]] +[[mpz_int (no Expression templates)][1 (0.00443395s)]] +[[tom_int][5.10595 (0.0226395s)]] +[[tom_int (no Expression templates)][61.9684 (0.274765s)]] +[[uint1024_t][9.32113 (0.0413295s)]] ] It's interesting to note that expression templates have little effect here - perhaps because the actual expressions involved diff --git a/doc/performance_overhead.qbk b/doc/performance_overhead.qbk index b730e6cfd..70abe7777 100644 --- a/doc/performance_overhead.qbk +++ b/doc/performance_overhead.qbk @@ -34,7 +34,7 @@ for the [@../../performance/voronoi_performance.cpp voronoi-diagram builder test [table [[Type][Relative time]] -[[`int64_t`][[*1.0](0.0128646s)]] +[[`int64_t`][[*1.0] (0.0128646s)]] [[`number, et_off>`][1.005 (0.0129255s)]] ] diff --git a/doc/performance_rational_real_world.qbk b/doc/performance_rational_real_world.qbk index 6d09a805d..004a8d9b7 100644 --- a/doc/performance_rational_real_world.qbk +++ b/doc/performance_rational_real_world.qbk @@ -55,7 +55,7 @@ calculate the n'th Bernoulli number via mixed rational/integer arithmetic to giv [[198][167.594528][0.8947434429][1.326461858]] ] -In this use case, most the of the rational numbers are fairly small and so the times taken are dominated by +In this use case, most of the rational numbers are fairly small and so the times taken are dominated by the number of allocations performed. The following table illustrates how well each type performs on suppressing allocations: diff --git a/doc/performance_real_world.qbk b/doc/performance_real_world.qbk index 2e21aa4cb..6d394e66e 100644 --- a/doc/performance_real_world.qbk +++ b/doc/performance_real_world.qbk @@ -23,12 +23,12 @@ increases contension inside new/delete. [[cpp_dec_float_50 (3 concurrent threads)][5.66114 (0.524077s)][424]] [[mpf_float_50][1.03648 (0.0959515s)][640961]] [[mpf_float_50 (3 concurrent threads)][1.50439 (0.139268s)][2563517]] -[[mpf_float_50 (no expression templates][1 (0.0925745s)][1019039]] -[[mpf_float_50 (no expression templates (3 concurrent threads)][1.52451 (0.141131s)][4075842]] +[[mpf_float_50 (no expression templates)][1 (0.0925745s)][1019039]] +[[mpf_float_50 (no expression templates) (3 concurrent threads)][1.52451 (0.141131s)][4075842]] [[mpfr_float_50][1.2513 (0.115838s)][583054]] [[mpfr_float_50 (3 concurrent threads)][1.61301 (0.149324s)][2330876]] -[[mpfr_float_50 (no expression templates][1.42667 (0.132073s)][999594]] -[[mpfr_float_50 (no expression templates (3 concurrent threads)][2.00203 (0.185337s)][4000039]] +[[mpfr_float_50 (no expression templates)][1.42667 (0.132073s)][999594]] +[[mpfr_float_50 (no expression templates) (3 concurrent threads)][2.00203 (0.185337s)][4000039]] [[static_mpfr_float_50][1.18358 (0.10957s)][22930]] [[static_mpfr_float_50 (3 concurrent threads)][1.38802 (0.128496s)][93140]] [[static_mpfr_float_50 (no expression templates)][1.14598 (0.106089s)][46861]] @@ -41,9 +41,9 @@ increases contension inside new/delete. [[cpp_bin_float_50 (3 concurrent threads)][3.50535 (56.6s)][28]] [[cpp_dec_float_50][4.82763 (77.9505s)][0]] [[mpf_float_50][1.06817 (17.2475s)][123749688]] -[[mpf_float_50 (no expression templates][1 (16.1468s)][152610085]] +[[mpf_float_50 (no expression templates)][1 (16.1468s)][152610085]] [[mpfr_float_50][1.18754 (19.1749s)][118401290]] -[[mpfr_float_50 (no expression templates][1.36782 (22.0858s)][152816346]] +[[mpfr_float_50 (no expression templates)][1.36782 (22.0858s)][152816346]] [[static_mpfr_float_50][1.04471 (16.8686s)][113395]] ] diff --git a/doc/reference_backend_requirements.qbk b/doc/reference_backend_requirements.qbk index 7fac05a80..2d94a25ef 100644 --- a/doc/reference_backend_requirements.qbk +++ b/doc/reference_backend_requirements.qbk @@ -20,7 +20,7 @@ Optional requirements have default implementations that are called if the backen its own. Typically the backend will implement these to improve performance. In the following tables, type B is the `Backend` template argument to `number`, `b` and `b2` are -a variables of type B, `pb` is a variable of type B*, `cb`, `cb2` and `cb3` are constant variables of type `const B`, +variables of type B, `pb` is a variable of type B*, `cb`, `cb2` and `cb3` are constant variables of type `const B`, `rb` is a variable of type `B&&`, `a` and `a2` are variables of Arithmetic type, `s` is a variable of type `const char*`, `ui` is a variable of type `unsigned`, `bb` is a variable of type `bool`, `pa` is a variable of type pointer-to-arithmetic-type, `exp` is a variable of type `B::exp_type`, @@ -40,7 +40,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`B()`][ ][Default constructor.][[space]]] [[`B(cb)`][ ][Copy Constructor.][[space]]] [[`b = b`][`B&`][Assignment operator.][[space]]] -[[`b = a`][`B&`][Assignment from an Arithmetic type. The type of `a` shall be listed in one of the type lists +[[`b = a`][`B&`][Assignment from an Arithmetic type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]] [[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpreted as a valid number.]] [[`b.swap(b)`][`void`][Swaps the contents of its arguments.][`noexcept`]] @@ -50,7 +50,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`cb.compare(cb2)`][`int`][Compares `cb` and `cb2`, returns a value less than zero if `cb < cb2`, a value greater than zero if `cb > cb2` and zero if `cb == cb2`.][`noexcept`]] [[`cb.compare(a)`][`int`][Compares `cb` and `a`, returns a value less than zero if `cb < a`, a value greater than zero if `cb > a` and zero - if `cb == a`. The type of `a` shall be listed in one of the type lists + if `cb == a`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]] [[`eval_add(b, cb)`][`void`][Adds `cb` to `b`.][[space]]] [[`eval_subtract(b, cb)`][`void`][Subtracts `cb` from `b`.][[space]]] @@ -65,7 +65,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`eval_complement(b, cb)`][`void`][Computes the ones-complement of `cb` and stores the result in `b`, only required when `B` is an integer type.][[space]]] [[`eval_left_shift(b, ui)`][`void`][Computes `b <<= ui`, only required when `B` is an integer type.][[space]]] [[`eval_right_shift(b, ui)`][`void`][Computes `b >>= ui`, only required when `B` is an integer type.][[space]]] -[[`eval_convert_to(pa, cb)`][`void`][Converts `cb` to the type of `*pa` and store the result in `*pa`. Type `B` shall support +[[`eval_convert_to(pa, cb)`][`void`][Converts `cb` to the type of `*pa` and stores the result in `*pa`. Type `B` shall support conversion to at least types `std::intmax_t`, `std::uintmax_t` and `long long`. Conversion to other arithmetic types can then be synthesised using other operations. Conversions to other types are entirely optional.][[space]]] @@ -77,7 +77,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`eval_floor(b, cb)`][`void`][Stores the floor of `cb` in `b`, only required when `B` is a floating-point type.][[space]]] [[`eval_ceil(b, cb)`][`void`][Stores the ceiling of `cb` in `b`, only required when `B` is a floating-point type.][[space]]] [[`eval_sqrt(b, cb)`][`void`][Stores the square root of `cb` in `b`, only required when `B` is a floating-point type.][[space]]] -[[`boost::multiprecision::number_category::type`][`std::integral_constant`][`N` is one of the values `number_kind_integer`, `number_kind_floating_point`, `number_kind_complex`, `number_kind_rational` or `number_kind_fixed_point`. +[[`boost::multiprecision::number_category::type`][`std::integral_constant`][`N` is the value `number_kind_integer`, `number_kind_floating_point`, `number_kind_complex`, `number_kind_rational` or `number_kind_fixed_point`. Defaults to `number_kind_floating_point`.][[space]]] [[`eval_conj(b, cb)`][`void`][Sets `b` to the complex conjugate of `cb`. Required for complex types only - other types have a sensible default.][[space]]] [[`eval_proj(b, cb)`][`void`][Sets `b` to the Riemann projection of `cb`. Required for complex types only - other types have a sensible default.][[space]]] @@ -95,7 +95,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. Only destruction and assignment to the moved-from variable `rb` need be supported after the operation.][`noexcept`]] [[`b = rb`][`B&`][Move-assign. Afterwards variable `rb` shall be in sane state, albeit with unspecified value. Only destruction and assignment to the moved-from variable `rb` need be supported after the operation.][`noexcept`]] -[[`B(a)`][`B`][Direct construction from an arithmetic type. The type of `a` shall be listed in one of the type lists +[[`B(a)`][`B`][Direct construction from an arithmetic type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, this operation is simulated using default-construction followed by assignment.][[space]]] [[`B(b2)`][`B`][Copy constructor from a different back-end type. When not provided, a generic interconversion routine is used. @@ -112,31 +112,31 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`eval_eq(cb, cb2)`][`bool`][Returns `true` if `cb` and `cb2` are equal in value. When not provided, the default implementation returns `cb.compare(cb2) == 0`.][`noexcept`]] [[`eval_eq(cb, a)`][`bool`][Returns `true` if `cb` and `a` are equal in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, return the equivalent of `eval_eq(cb, B(a))`.][[space]]] [[`eval_eq(a, cb)`][`bool`][Returns `true` if `cb` and `a` are equal in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version returns `eval_eq(cb, a)`.][[space]]] [[`eval_lt(cb, cb2)`][`bool`][Returns `true` if `cb` is less than `cb2` in value. When not provided, the default implementation returns `cb.compare(cb2) < 0`.][`noexcept`]] [[`eval_lt(cb, a)`][`bool`][Returns `true` if `cb` is less than `a` in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default implementation returns `eval_lt(cb, B(a))`.][[space]]] [[`eval_lt(a, cb)`][`bool`][Returns `true` if `a` is less than `cb` in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default implementation returns `eval_gt(cb, a)`.][[space]]] [[`eval_gt(cb, cb2)`][`bool`][Returns `true` if `cb` is greater than `cb2` in value. When not provided, the default implementation returns `cb.compare(cb2) > 0`.][`noexcept`]] [[`eval_gt(cb, a)`][`bool`][Returns `true` if `cb` is greater than `a` in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default implementation returns `eval_gt(cb, B(a))`.][[space]]] [[`eval_gt(a, cb)`][`bool`][Returns `true` if `a` is greater than `cb` in value. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default implementation returns `eval_lt(cb, a)`.][[space]]] [[`eval_is_zero(cb)`][`bool`][Returns `true` if `cb` is zero, otherwise `false`. The default version of this function @@ -148,87 +148,87 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]] [[['Basic arithmetic:]]] -[[`eval_add(b, a)`][`void`][Adds `a` to `b`. The type of `a` shall be listed in one of the type lists +[[`eval_add(b, a)`][`void`][Adds `a` to `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_add(b, B(a))`][[space]]] -[[`eval_add(b, cb, cb2)`][`void`][Add `cb` to `cb2` and stores the result in `b`. +[[`eval_add(b, cb, cb2)`][`void`][Adds `cb` to `cb2` and stores the result in `b`. When not provided, does the equivalent of `b = cb; eval_add(b, cb2)`.][[space]]] -[[`eval_add(b, cb, a)`][`void`][Add `cb` to `a` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_add(b, cb, a)`][`void`][Adds `cb` to `a` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_add(b, cb, B(a))`.][[space]]] -[[`eval_add(b, a, cb)`][`void`][Add `a` to `cb` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_add(b, a, cb)`][`void`][Adds `a` to `cb` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_add(b, cb, a)`.][[space]]] -[[`eval_subtract(b, a)`][`void`][Subtracts `a` from `b`. The type of `a` shall be listed in one of the type lists +[[`eval_subtract(b, a)`][`void`][Subtracts `a` from `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_subtract(b, B(a))`][[space]]] [[`eval_subtract(b, cb, cb2)`][`void`][Subtracts `cb2` from `cb` and stores the result in `b`. When not provided, does the equivalent of `b = cb; eval_subtract(b, cb2)`.][[space]]] -[[`eval_subtract(b, cb, a)`][`void`][Subtracts `a` from `cb` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_subtract(b, cb, a)`][`void`][Subtracts `a` from `cb` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_subtract(b, cb, B(a))`.][[space]]] -[[`eval_subtract(b, a, cb)`][`void`][Subtracts `cb` from `a` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_subtract(b, a, cb)`][`void`][Subtracts `cb` from `a` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_subtract(b, cb, a); b.negate();`.][[space]]] -[[`eval_multiply(b, a)`][`void`][Multiplies `b` by `a`. The type of `a` shall be listed in one of the type lists +[[`eval_multiply(b, a)`][`void`][Multiplies `b` by `a`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_multiply(b, B(a))`][[space]]] [[`eval_multiply(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and stores the result in `b`. When not provided, does the equivalent of `b = cb; eval_multiply(b, cb2)`.][[space]]] -[[`eval_multiply(b, cb, a)`][`void`][Multiplies `cb` by `a` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_multiply(b, cb, a)`][`void`][Multiplies `cb` by `a` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_multiply(b, cb, B(a))`.][[space]]] -[[`eval_multiply(b, a, cb)`][`void`][Multiplies `a` by `cb` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_multiply(b, a, cb)`][`void`][Multiplies `a` by `cb` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_multiply(b, cb, a)`.][[space]]] [[`eval_multiply_add(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and adds the result to `b`. When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, cb2)` followed by `eval_add(b, t)`.][[space]]] [[`eval_multiply_add(b, cb, a)`][`void`][Multiplies `a` by `cb` and adds the result to `b`. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, a)` followed by `eval_add(b, t)`.][[space]]] [[`eval_multiply_add(b, a, cb)`][`void`][Multiplies `a` by `cb` and adds the result to `b`. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided does the equivalent of `eval_multiply_add(b, cb, a)`.][[space]]] [[`eval_multiply_subtract(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and subtracts the result from `b`. When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, cb2)` followed by `eval_subtract(b, t)`.][[space]]] [[`eval_multiply_subtract(b, cb, a)`][`void`][Multiplies `a` by `cb` and subtracts the result from `b`. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, a)` followed by `eval_subtract(b, t)`.][[space]]] [[`eval_multiply_subtract(b, a, cb)`][`void`][Multiplies `a` by `cb` and subtracts the result from `b`. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided does the equivalent of `eval_multiply_subtract(b, cb, a)`.][[space]]] [[`eval_multiply_add(b, cb, cb2, cb3)`][`void`][Multiplies `cb` by `cb2` and adds the result to `cb3` storing the result in `b`. When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by `eval_add(b, cb3)`. For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of - `cb`, `cb2` and `cb3` with any type listed in one of the type lists + `cb`, `cb2` and `cb3` with any type listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]] [[`eval_multiply_subtract(b, cb, cb2, cb3)`][`void`][Multiplies `cb` by `cb2` and subtracts from the result `cb3` storing the result in `b`. When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by `eval_subtract(b, cb3)`. For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of - `cb`, `cb2` and `cb3` with any type listed in one of the type lists + `cb`, `cb2` and `cb3` with any type listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]] -[[`eval_divide(b, a)`][`void`][Divides `b` by `a`. The type of `a` shall be listed in one of the type lists +[[`eval_divide(b, a)`][`void`][Divides `b` by `a`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_divide(b, B(a))`] [`std::overflow_error` if `a` has the value zero, and `std::numeric_limits >::has_infinity == false`]] [[`eval_divide(b, cb, cb2)`][`void`][Divides `cb` by `cb2` and stores the result in `b`. When not provided, does the equivalent of `b = cb; eval_divide(b, cb2)`.] [`std::overflow_error` if `cb2` has the value zero, and `std::numeric_limits >::has_infinity == false`]] -[[`eval_divide(b, cb, a)`][`void`][Divides `cb` by `a` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_divide(b, cb, a)`][`void`][Divides `cb` by `a` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_divide(b, cb, B(a))`.] [`std::overflow_error` if `a` has the value zero, and `std::numeric_limits >::has_infinity == false`]] -[[`eval_divide(b, a, cb)`][`void`][Divides `a` by `cb` and stores the result in `b`. The type of `a` shall be listed in one of the type lists +[[`eval_divide(b, a, cb)`][`void`][Divides `a` by `cb` and stores the result in `b`. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_divide(b, B(a), cb)`.] [`std::overflow_error` if cb has the value zero, and `std::numeric_limits >::has_infinity == false`]] @@ -240,52 +240,52 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. Where `ui_type` is `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]] [[['Integer specific operations:]]] -[[`eval_modulus(b, a)`][`void`][Computes `b %= cb`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_modulus(b, a)`][`void`][Computes `b %= cb`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_modulus(b, B(a))`] [`std::overflow_error` if `a` has the value zero.]] [[`eval_modulus(b, cb, cb2)`][`void`][Computes `cb % cb2` and stores the result in `b`, only required when `B` is an integer type. When not provided, does the equivalent of `b = cb; eval_modulus(b, cb2)`.] [`std::overflow_error` if `a` has the value zero.]] -[[`eval_modulus(b, cb, a)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_modulus(b, cb, a)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_modulus(b, cb, B(a))`.] [`std::overflow_error` if `a` has the value zero.]] -[[`eval_modulus(b, a, cb)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_modulus(b, a, cb)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_modulus(b, B(a), cb)`.] [`std::overflow_error` if `a` has the value zero.]] -[[`eval_bitwise_and(b, a)`][`void`][Computes `b &= cb`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_and(b, a)`][`void`][Computes `b &= cb`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_bitwise_and(b, B(a))`][[space]]] [[`eval_bitwise_and(b, cb, cb2)`][`void`][Computes `cb & cb2` and stores the result in `b`, only required when `B` is an integer type. When not provided, does the equivalent of `b = cb; eval_bitwise_and(b, cb2)`.][[space]]] -[[`eval_bitwise_and(b, cb, a)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_and(b, cb, a)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_and(b, cb, B(a))`.][[space]]] -[[`eval_bitwise_and(b, a, cb)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_and(b, a, cb)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_and(b, cb, a)`.][[space]]] -[[`eval_bitwise_or(b, a)`][`void`][Computes `b |= cb`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_or(b, a)`][`void`][Computes `b |= cb`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_bitwise_or(b, B(a))`][[space]]] [[`eval_bitwise_or(b, cb, cb2)`][`void`][Computes `cb | cb2` and stores the result in `b`, only required when `B` is an integer type. When not provided, does the equivalent of `b = cb; eval_bitwise_or(b, cb2)`.][[space]]] -[[`eval_bitwise_or(b, cb, a)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_or(b, cb, a)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_or(b, cb, B(a))`.][[space]]] -[[`eval_bitwise_or(b, a, cb)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_or(b, a, cb)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_or(b, cb, a)`.][[space]]] -[[`eval_bitwise_xor(b, a)`][`void`][Computes `b ^= cb`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_xor(b, a)`][`void`][Computes `b ^= cb`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, the default version calls `eval_bitwise_xor(b, B(a))`][[space]]] [[`eval_bitwise_xor(b, cb, cb2)`][`void`][Computes `cb ^ cb2` and stores the result in `b`, only required when `B` is an integer type. When not provided, does the equivalent of `b = cb; eval_bitwise_xor(b, cb2)`.][[space]]] -[[`eval_bitwise_xor(b, cb, a)`][`void`][Computes `cb ^ a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_xor(b, cb, a)`][`void`][Computes `cb ^ a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_xor(b, cb, B(a))`.][[space]]] -[[`eval_bitwise_xor(b, a, cb)`][`void`][Computes `a ^ cb` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists +[[`eval_bitwise_xor(b, a, cb)`][`void`][Computes `a ^ cb` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. When not provided, does the equivalent of `eval_bitwise_xor(b, cb, a)`.][[space]]] [[`eval_left_shift(b, cb, ui)`][`void`][Computes `cb << ui` and stores the result in `b`, only required when `B` is an integer type. @@ -315,37 +315,37 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`eval_lcm(b, cb, cb2)`][`void`][Sets `b` to the least common multiple of `cb` and `cb2`. Only required when `B` is an integer type. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_gcd(b, cb, a)`][`void`][Sets `b` to the greatest common divisor of `cb` and `cb2`. Only required when `B` is an integer type. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. The default version of this function calls `eval_gcd(b, cb, B(a))`.][[space]]] [[`eval_lcm(b, cb, a)`][`void`][Sets `b` to the least common multiple of `cb` and `cb2`. Only required when `B` is an integer type. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. The default version of this function calls `eval_lcm(b, cb, B(a))`.][[space]]] [[`eval_gcd(b, a, cb)`][`void`][Sets `b` to the greatest common divisor of `cb` and `a`. Only required when `B` is an integer type. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. The default version of this function calls `eval_gcd(b, cb, a)`.][[space]]] [[`eval_lcm(b, a, cb)`][`void`][Sets `b` to the least common multiple of `cb` and `a`. Only required when `B` is an integer type. - The type of `a` shall be listed in one of the type lists + The type of `a` shall be listed in `B::signed_types`, `B::unsigned_types` or `B::float_types`. The default version of this function calls `eval_lcm(b, cb, a)`.][[space]]] [[`eval_powm(b, cb, cb2, cb3)`][`void`][Sets `b` to the result of ['(cb^cb2)%cb3]. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_powm(b, cb, cb2, a)`][`void`][Sets `b` to the result of ['(cb^cb2)%a]. - The type of `a` shall be listed in one of the type lists - `B::signed_types`, `B::unsigned_types`. + The type of `a` shall be listed in + `B::signed_types` or `B::unsigned_types`. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_powm(b, cb, a, cb2)`][`void`][Sets `b` to the result of ['(cb^a)%cb2]. - The type of `a` shall be listed in one of the type lists - `B::signed_types`, `B::unsigned_types`. + The type of `a` shall be listed in + `B::signed_types` or `B::unsigned_types`. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_powm(b, cb, a, a2)`][`void`][Sets `b` to the result of ['(cb^a)%a2]. - The type of `a` shall be listed in one of the type lists - `B::signed_types`, `B::unsigned_types`. + The type of `a` shall be listed in + `B::signed_types` or `B::unsigned_types`. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_integer_sqrt(b, cb, b2)`][`void`][Sets `b` to the largest integer which when squared is less than `cb`, also - sets `b2` to the remainder, ie to ['cb - b[super 2]]. + sets `b2` to the remainder, i.e. to ['cb - b[super 2]]. The default version of this function is synthesised from other operations above.][[space]]] [[['Sign manipulation:]]] @@ -357,39 +357,39 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. `eval_get_sign(cb) < 0`.][[space]]] [[['floating-point functions:]]] -[[`eval_fpclassify(cb)`][`int`][Returns one of the same values returned by `std::fpclassify`. Only required when `B` is an floating-point type. +[[`eval_fpclassify(cb)`][`int`][Returns one of the same values returned by `std::fpclassify`. Only required when `B` is a floating-point type. The default version of this function will only test for zero `cb`.][[space]]] -[[`eval_trunc(b, cb)`][`void`][Performs the equivalent operation to `std::trunc` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_trunc(b, cb)`][`void`][Performs the equivalent operation to `std::trunc` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_round(b, cb)`][`void`][Performs the equivalent operation to `std::round` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_round(b, cb)`][`void`][Performs the equivalent operation to `std::round` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_exp(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_exp(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_exp2(b, cb)`][`void`][Performs the equivalent operation to `std::exp2` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_exp2(b, cb)`][`void`][Performs the equivalent operation to `std::exp2` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is implemented in terms of `eval_pow`.][[space]]] -[[`eval_log(b, cb)`][`void`][Performs the equivalent operation to `std::log` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_log(b, cb)`][`void`][Performs the equivalent operation to `std::log` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_log10(b, cb)`][`void`][Performs the equivalent operation to `std::log10` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_log10(b, cb)`][`void`][Performs the equivalent operation to `std::log10` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_sin(b, cb)`][`void`][Performs the equivalent operation to `std::sin` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_sin(b, cb)`][`void`][Performs the equivalent operation to `std::sin` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_cos(b, cb)`][`void`][Performs the equivalent operation to `std::cos` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_cos(b, cb)`][`void`][Performs the equivalent operation to `std::cos` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_tan(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_tan(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_asin(b, cb)`][`void`][Performs the equivalent operation to `std::asin` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_asin(b, cb)`][`void`][Performs the equivalent operation to `std::asin` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_acos(b, cb)`][`void`][Performs the equivalent operation to `std::acos` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_acos(b, cb)`][`void`][Performs the equivalent operation to `std::acos` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_atan(b, cb)`][`void`][Performs the equivalent operation to `std::atan` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_atan(b, cb)`][`void`][Performs the equivalent operation to `std::atan` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_sinh(b, cb)`][`void`][Performs the equivalent operation to `std::sinh` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_sinh(b, cb)`][`void`][Performs the equivalent operation to `std::sinh` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_cosh(b, cb)`][`void`][Performs the equivalent operation to `std::cosh` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_cosh(b, cb)`][`void`][Performs the equivalent operation to `std::cosh` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_tanh(b, cb)`][`void`][Performs the equivalent operation to `std::tanh` on argument `cb` and stores the result in `b`. Only required when `B` is an floating-point type. +[[`eval_tanh(b, cb)`][`void`][Performs the equivalent operation to `std::tanh` on argument `cb` and stores the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] -[[`eval_fmod(b, cb, cb2)`][`void`][Performs the equivalent operation to `std::fmod` on arguments `cb` and `cb2`, and store the result in `b`. Only required when `B` is an floating-point type. +[[`eval_fmod(b, cb, cb2)`][`void`][Performs the equivalent operation to `std::fmod` on arguments `cb` and `cb2`, and store the result in `b`. Only required when `B` is a floating-point type. The default version of this function is synthesised from other operations above.][[space]]] [[`eval_modf(b, cb, pb)`][`void`][Performs the equivalent operation to `std::modf` on argument `cb`, and store the integer result in `*pb` and the fractional part in `b`. Only required when `B` is an floating-point type. diff --git a/doc/reference_cpp_bin_float.qbk b/doc/reference_cpp_bin_float.qbk index f69992e3b..ffece91e6 100644 --- a/doc/reference_cpp_bin_float.qbk +++ b/doc/reference_cpp_bin_float.qbk @@ -79,7 +79,7 @@ Square root uses integer square root in a manner analogous to division. Decimal string to binary conversion proceeds as follows: first parse the digits to produce an integer multiplied by a decimal exponent. Note that we stop parsing digits -once we have parsed as many as can possibly effect the result - this stops the integer +once we have parsed as many as can possibly affect the result - this stops the integer part growing too large when there are a very large number of input digits provided. At this stage if the decimal exponent is positive then the result is an integer and we can in principle simply multiply by 10^N to get an exact integer result. In practice @@ -97,6 +97,6 @@ so that the result is an N bit integer assuming we want N digits printed in the As before we use limited precision arithmetic to calculate the result and up the precision as necessary until the result is unambiguously correctly rounded. In addition our initial calculation of the decimal exponent may be out by 1, so we have to correct -that and loop as well in the that case. +that and loop as well in that case. [endsect] diff --git a/doc/reference_cpp_double_fp_backend.qbk b/doc/reference_cpp_double_fp_backend.qbk index 49dc24e19..281c483ac 100644 --- a/doc/reference_cpp_double_fp_backend.qbk +++ b/doc/reference_cpp_double_fp_backend.qbk @@ -33,7 +33,7 @@ to change. The class takes one template parameter: [variablelist -[[FloatingPointType][The consituent IEEE floating-point value of the two limbs of the composite type. +[[FloatingPointType][The constituent IEEE floating-point value of the two limbs of the composite type. This can be `float`, `double`, `long double` or when available `boost::float128_type`.]] ] diff --git a/doc/reference_internal_support.qbk b/doc/reference_internal_support.qbk index d45db056e..9313246ec 100644 --- a/doc/reference_internal_support.qbk +++ b/doc/reference_internal_support.qbk @@ -30,7 +30,7 @@ Inherits from `std::integral_constant` if type `From` has an explicit Member `value` is true if the conversion from `From` to `To` would result in a loss of precision, and `false` otherwise. The default version of this trait simply checks whether the ['kind] of conversion (for example from a floating-point to an integer type) -is inherently lossy. Note that if either of the types `From` or `To` are of an unknown number category (because `number_category` is not +is inherently lossy. Note that if either of the types `From` and `To` is of an unknown number category (because `number_category` is not specialised for that type) then this trait will be `true`. template diff --git a/doc/reference_number.qbk b/doc/reference_number.qbk index 455def21f..c8e707b11 100644 --- a/doc/reference_number.qbk +++ b/doc/reference_number.qbk @@ -398,7 +398,7 @@ integer type with a positive value (negative values result in a `std::runtime_er Returns an ['unmentionable-type] that is usable in Boolean contexts (this allows `number` to be used in any Boolean context - if statements, conditional statements, or as an argument to a logical operator - without -type `number` being convertible to type `bool`. +type `number` being convertible to type `bool`). This operator also enables the use of `number` with any of the following operators: `!`, `||`, `&&` and `?:`. @@ -633,7 +633,7 @@ that allows arithmetic to be performed on native integer types producing an exte bool isunordered(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&); These functions all behave exactly as their standard library C++11 counterparts do: their argument is either an instance of `number` or -an expression template derived from it; If the argument is of type `number` then that is also the return type, +an expression template derived from it; if the argument is of type `number` then that is also the return type, otherwise the return type is an expression template unless otherwise stated. The integer type arguments to `ldexp`, `frexp`, `scalbn` and `ilogb` may be either type `int`, or the actual @@ -651,7 +651,7 @@ Complex number types support the following functions: ``['number]`` proj (const ``['number-or-expression-template-type]``&); ``['number]`` polar (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&); -In addition the functions `real`, `imag`, `arg`, `norm`, `conj` and `proj` are overloaded for scalar (ie non-complex) types in the same +In addition the functions `real`, `imag`, `arg`, `norm`, `conj` and `proj` are overloaded for scalar (i.e. non-complex) types in the same manner as `` and treat the argument as a value whose imaginary part is zero. There are also some functions implemented for compatibility with the Boost.Math functions of the same name: @@ -668,7 +668,7 @@ don't have native support for these functions. Please note however, that this d to be a compile time constant - this means for example that the [gmp] MPF Backend will not work with these functions when that type is used at variable precision. -Also note that with the exception of `abs` that these functions can only be used with floating-point Backend types (if any other types +Also note that with the exception of `abs` these functions can only be used with floating-point Backend types (if any other types such as fixed precision or complex types are added to the library later, then these functions may be extended to support those number types). The precision of these functions is generally determined by the backend implementation. For example the precision @@ -693,7 +693,7 @@ here are exact (tested on Win32 with VC++10, MPFR-3.0.0, MPIR-2.1.1): [[acos][0eps][0eps][0eps]] [[asin][0eps][0eps][0eps]] [[atan][1eps][0eps][0eps]] -[[cosh][1045eps[footnote It's likely that the inherent error in the input values to our test cases are to blame here.]][0eps][0eps]] +[[cosh][1045eps[footnote It's likely that inherent errors in the input values to our test cases are to blame here.]][0eps][0eps]] [[sinh][2eps][0eps][0eps]] [[tanh][1eps][0eps][0eps]] [[pow][0eps][4eps][3eps]] diff --git a/doc/tutorial.qbk b/doc/tutorial.qbk index a9deff5a2..b7798fe1c 100644 --- a/doc/tutorial.qbk +++ b/doc/tutorial.qbk @@ -13,8 +13,8 @@ In order to use this library you need to make two choices: * What kind of number do I want ([link boost_multiprecision.tut.ints integer], -[link boost_multiprecision.tut.floats floating-point], [link boost_multiprecision.tut.rational rational], or [link boost_multiprecision.tut.complex complex]). -* Which back-end do I want to perform the actual arithmetic (Boost-supplied, GMP, MPFR, MPC, Tommath etc)? +[link boost_multiprecision.tut.floats floating-point], [link boost_multiprecision.tut.rational rational], or [link boost_multiprecision.tut.complex complex])? +* Which back-end do I want to perform the actual arithmetic (Boost-supplied, GMP, MPFR, MPC, Tommath etc.)? A practical, comprehensive, instructive, clear and very helpful video regarding the use of Multiprecision can be found [@https://www.youtube.com/watch?v=mK4WjpvLj4c here]. diff --git a/doc/tutorial_complex_adaptor.qbk b/doc/tutorial_complex_adaptor.qbk index 94629484c..5a36acd34 100644 --- a/doc/tutorial_complex_adaptor.qbk +++ b/doc/tutorial_complex_adaptor.qbk @@ -17,7 +17,7 @@ }} -Class template `complex_adaptor` is designed to sit inbetween class `number` and an actual floating point backend, +Class template `complex_adaptor` is designed to sit in between class `number` and an actual floating point backend, in order to create a new complex number type. It is the means by which we implement __cpp_complex and __complex128. diff --git a/doc/tutorial_constexpr.qbk b/doc/tutorial_constexpr.qbk index 43125fd53..f04b75f7c 100644 --- a/doc/tutorial_constexpr.qbk +++ b/doc/tutorial_constexpr.qbk @@ -5,23 +5,23 @@ 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). + http://www.boost.org/LICENSE_1_0.txt.) ] [section:lits Literal Types and `constexpr` Support] There are two kinds of `constexpr` support in this library: -* The more basic version requires only C++11 and allow the construction of some number types as literals. +* The more basic version requires only C++11 and allows the construction of some number types as literals. * The more advanced support permits constexpr arithmetic and requires at least C++14 -constexpr support, and for many operations C++2a support +constexpr support, and for many operations C++2a support. [h4 Declaring numeric literals] There are two backend types which are literals: * __float128__ (which requires GCC), and -* Instantiations of `cpp_int_backend` where the Allocator parameter is type `void`. +* instantiations of `cpp_int_backend` where the Allocator parameter is type `void`. In addition, prior to C++14 the Checked parameter must be `boost::multiprecision::unchecked`. For example: @@ -114,13 +114,13 @@ or GCC-6 or later in C++14 mode. Compilers other than GCC and without `std::is_constant_evaluated()` will support a very limited set of operations: expect to hit roadblocks rather easily. -See __compiler_support for __is_constant_evaluated; +See __compiler_support for __is_constant_evaluated. -For example given: +For example, given [constexpr_circle] -We can now calculate areas and circumferences, using all compile-time `constexpr` arithmetic: +we can now calculate areas and circumferences, using all compile-time `constexpr` arithmetic: [constexpr_circle_usage] diff --git a/doc/tutorial_conversions.qbk b/doc/tutorial_conversions.qbk index 15aafdf6f..e0ed70c50 100644 --- a/doc/tutorial_conversions.qbk +++ b/doc/tutorial_conversions.qbk @@ -16,14 +16,14 @@ In particular: * Any number type can be constructed (or assigned) from any __fundamental arithmetic type, as long as the conversion isn't lossy (for example float to int conversion): - cpp_dec_float_50 df(0.5); // OK construction from double - cpp_int i(450); // OK constructs from signed int + cpp_dec_float_50 df(0.5); // OK, construction from double + cpp_int i(450); // OK, constructs from signed int cpp_int j = 3.14; // Error, lossy conversion. * A number can be explicitly constructed from an arithmetic type, even when the conversion is lossy: - cpp_int i(3.14); // OK explicit conversion - i = static_cast(3.14) // OK explicit conversion + cpp_int i(3.14); // OK, explicit conversion + i = static_cast(3.14) // OK, explicit conversion i.assign(3.14); // OK, explicit assign and avoid a temporary from the cast above i = 3.14; // Error, no implicit assignment operator for lossy conversion. cpp_int j = 3.14; // Error, no implicit constructor for lossy conversion. @@ -50,7 +50,7 @@ this functionality is only available on compilers supporting C++11's explicit co mpz_int z(2); int i = z; // Error, implicit conversion not allowed. - int j = static_cast(z); // OK explicit conversion. + int j = static_cast(z); // OK, explicit conversion. * Any number type can be ['explicitly] constructed (or assigned) from a `const char*` or a `std::string`: @@ -93,7 +93,7 @@ are not lossy: loss of precision is involved, and explicit if it is: int128_t i128 = 0; - int266_t i256 = i128; // OK implicit widening conversion + int266_t i256 = i128; // OK, implicit widening conversion i128_t = i256; // Error, no assignment operator found, narrowing conversion is explicit. i128_t = static_cast(i256); // OK, explicit narrowing conversion. @@ -126,6 +126,6 @@ loss of precision is involved, and explicit if it is: More information on what additional types a backend supports conversions from are given in the tutorial for each backend. The converting constructor will be implicit if the backend's converting constructor is also implicit, and explicit if the -backends converting constructor is also explicit. +backend's converting constructor is also explicit. [endsect] [/section:conversions Constructing and Interconverting Between Number Types] diff --git a/doc/tutorial_cpp_bin_float.qbk b/doc/tutorial_cpp_bin_float.qbk index 77fb2c418..81b4372be 100644 --- a/doc/tutorial_cpp_bin_float.qbk +++ b/doc/tutorial_cpp_bin_float.qbk @@ -47,10 +47,10 @@ to declare a `cpp_bin_float` with exactly the same precision as `double` one wou `number >`. The typedefs `cpp_bin_float_single`, `cpp_bin_float_double`, `cpp_bin_float_quad`, `cpp_bin_float_oct` and `cpp_bin_float_double_extended` provide software analogues of the IEEE single, double, quad and octuple float data types, plus the Intel-extended-double type respectively. -Note that while these types are functionally equivalent to the native IEEE types, but they do not have the same size +Note that while these types are functionally equivalent to the native IEEE types, they do not have the same size or bit-layout as true IEEE compatible types. -Normally `cpp_bin_float` allocates no memory: all of the space required for its digits are allocated +Normally `cpp_bin_float` allocates no memory: all of the space required for its digits is allocated directly within the class. As a result care should be taken not to use the class with too high a digit count as stack space requirements can grow out of control. If that represents a problem then providing an allocator as a template parameter causes `cpp_bin_float` to dynamically allocate the memory it needs: this @@ -77,13 +77,13 @@ Things you should know when using this type: * The type supports both infinities and NaNs. An infinity is generated whenever the result would overflow, and a NaN is generated for any mathematically undefined operation. * There is a `std::numeric_limits` specialisation for this type. -* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type - +* Any `number` instantiated on this type is convertible to any other `number` instantiated on this type - for example you can convert from `number >` to `number >`. Narrowing conversions round to nearest and are `explicit`. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid floating-point number. * All arithmetic operations are correctly rounded to nearest. String conversions and the `sqrt` function -are also correctly rounded, but transcendental functions (sin, cos, pow, exp etc) are not. +are also correctly rounded, but transcendental functions (sin, cos, pow, exp etc.) are not. [h5 cpp_bin_float example:] diff --git a/doc/tutorial_cpp_complex.qbk b/doc/tutorial_cpp_complex.qbk index 8e4443b5b..df4db9002 100644 --- a/doc/tutorial_cpp_complex.qbk +++ b/doc/tutorial_cpp_complex.qbk @@ -63,7 +63,7 @@ is completely opaque, the suggestion would be to use an allocator with `char` `v The next template parameters determine the type and range of the exponent: parameter `Exponent` can be any signed integer type, but note that `MinExponent` and `MaxExponent` can not go right up to the limits of the `Exponent` type as there has to be a little extra headroom for internal calculations. You will -get a compile time error if this is the case. In addition if MinExponent or MaxExponent are zero, then +get a compile time error if this is the case. In addition if MinExponent or MaxExponent is zero, then the library will choose suitable values that are as large as possible given the constraints of the type and need for extra headroom for internal calculations. @@ -75,13 +75,13 @@ There is full standard library support available for this type, comparable with Things you should know when using this type: -* Default constructed `cpp_complex`s have a value of zero. +* Default constructed `cpp_complex`es have a value of zero. * The radix of this type is 2, even when the precision is specified as decimal digits. * The type supports both infinities and NaNs. An infinity is generated whenever the result would overflow, and a NaN is generated for any mathematically undefined operation. * There is no `std::numeric_limits` specialisation for this type: this is the same behaviour as `std::complex`. If you need `std::numeric_limits` support you need to look at `std::numeric_limits`. -* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type - +* Any `number` instantiated on this type is convertible to any other `number` instantiated on this type - for example you can convert from `number >` to `number >`. Narrowing conversions round to nearest and are `explicit`. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted diff --git a/doc/tutorial_cpp_dec_float.qbk b/doc/tutorial_cpp_dec_float.qbk index 0fea0a7f5..4b30c680c 100644 --- a/doc/tutorial_cpp_dec_float.qbk +++ b/doc/tutorial_cpp_dec_float.qbk @@ -52,7 +52,7 @@ Normally these should not be visible to the user. * The type supports both infinities and NaNs. An infinity is generated whenever the result would overflow, and a NaN is generated for any mathematically undefined operation. * There is a `std::numeric_limits` specialisation for this type. -* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type - +* Any `number` instantiated on this type is convertible to any other `number` instantiated on this type - for example you can convert from `number >` to `number >`. Narrowing conversions are truncating and `explicit`. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted diff --git a/doc/tutorial_cpp_int.qbk b/doc/tutorial_cpp_int.qbk index 2ef36310a..661b31461 100644 --- a/doc/tutorial_cpp_int.qbk +++ b/doc/tutorial_cpp_int.qbk @@ -97,13 +97,13 @@ and unchecked integers have the following properties: [table [[Condition][Checked-Integer][Unchecked-Integer]] -[[Numeric overflow in fixed precision arithmetic][Throws a `std::overflow_error`.][Performs arithmetic modulo 2[super MaxBits]]] +[[Numeric overflow in fixed precision arithmetic][Throws a `std::overflow_error`.][Performs arithmetic modulo 2[super MaxBits].]] [[Constructing an integer from a value that can not be represented in the target type][Throws a `std::range_error`.] [Converts the value modulo 2[super MaxBits], signed to unsigned conversions extract the last MaxBits bits of the 2's complement representation of the input value.]] -[[Unsigned subtraction yielding a negative value.][Throws a `std::range_error`.][Yields the value that would +[[Unsigned subtraction yielding a negative value][Throws a `std::range_error`.][Yields the value that would result from treating the unsigned type as a 2's complement signed type.]] -[[Attempting a bitwise operation on a negative value.][Throws a `std::range_error`][Yields the value, but not the bit pattern, +[[Attempting a bitwise operation on a negative value][Throws a `std::range_error`][Yields the value, but not the bit pattern, that would result from performing the operation on a 2's complement integer type.]] ] @@ -150,7 +150,7 @@ this includes the "checked" variants. Small signed types will always have an ex * When used at fixed precision and MaxBits is smaller than the number of bits in the largest native integer type, then internally `cpp_int_backend` switches to a "trivial" implementation where it is just a thin wrapper around a single integer. Note that it will still be slightly slower than a bare native integer, as it emulates a -signed-magnitude representation rather than simply using the platforms native sign representation: this ensures +signed-magnitude representation rather than simply using the platform's native sign representation: this ensures there is no step change in behavior as a cpp_int grows in size. * Fixed precision `cpp_int`'s have some support for `constexpr` values and user-defined literals, see [link boost_multiprecision.tut.lits here] for the full description. For example `0xfffff_cppi1024` diff --git a/doc/tutorial_debug_adaptor.qbk b/doc/tutorial_debug_adaptor.qbk index 55de94a30..96758091b 100644 --- a/doc/tutorial_debug_adaptor.qbk +++ b/doc/tutorial_debug_adaptor.qbk @@ -40,7 +40,7 @@ It works for all the backend types equally too, here it is inspecting a `number< [$../debugger3.png] -The template alias `debug_adaptor_t` is used as a shortcut for converting some other number type to it's debugged equivalent, +The template alias `debug_adaptor_t` is used as a shortcut for converting some other number type to its debugged equivalent, for example: using mpfr_float_debug = debug_adaptor_t; diff --git a/doc/tutorial_float128.qbk b/doc/tutorial_float128.qbk index d308c98a5..f9a7684e2 100644 --- a/doc/tutorial_float128.qbk +++ b/doc/tutorial_float128.qbk @@ -21,7 +21,7 @@ }} // namespaces The `float128` number type is a very thin wrapper around GCC's `__float128` or Intel's `_Quad` data types -and provides an real-number type that is a drop-in replacement for the native C++ floating-point types, but with +and provides a real-number type that is a drop-in replacement for the native C++ floating-point types, but with a 113 bit mantissa, and compatible with FORTRAN's 128-bit QUAD real. All the usual standard library and `std::numeric_limits` support are available, performance should be equivalent @@ -37,7 +37,7 @@ function of `float128_backend`. Things you should know when using this type: * Default constructed `float128`s have the value zero. -* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware. +* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move-aware. * This type is fully `constexpr` aware - basic constexpr arithmetic is supported from C++14 and onwards, comparisons, plus the functions `fabs`, `abs`, `fpclassify`, `isnormal`, `isfinite`, `isinf` and `isnan` are also supported if either the compiler implements C++20's `std::is_constant_evaluated()`, or if the compiler is GCC. diff --git a/doc/tutorial_float128_complex.qbk b/doc/tutorial_float128_complex.qbk index 283f502fe..2403fabf9 100644 --- a/doc/tutorial_float128_complex.qbk +++ b/doc/tutorial_float128_complex.qbk @@ -33,7 +33,7 @@ copy constructible and assignable from GCC's `__float128` and Intel's `_Quad` da Things you should know when using this type: * Default constructed `complex128`s have the value zero. -* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware. +* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move-aware. * It is not possible to round-trip objects of this type to and from a string and get back exactly the same value when compiled with Intel's C++ compiler and using `_Quad` as the underlying type: this is a current limitation of our code. Round tripping when using `__float128` as the underlying type is possible (both for GCC and Intel). diff --git a/doc/tutorial_float_builtin_ctor.qbk b/doc/tutorial_float_builtin_ctor.qbk index 028a2637e..f8c3d3f2e 100644 --- a/doc/tutorial_float_builtin_ctor.qbk +++ b/doc/tutorial_float_builtin_ctor.qbk @@ -12,7 +12,7 @@ Construction of multiprecision types from built-in floating-point types can lead to potentially unexpected, yet correct, results. -Consider, for instance constructing an instance of `cpp_dec_float_50` +Consider, for instance, constructing an instance of `cpp_dec_float_50` from the literal built-in floating-point `double` value 11.1. #include @@ -35,7 +35,7 @@ from the literal built-in floating-point `double` value 11.1. << std::endl; } -In this example, the system has a 64-bit built in `double` representation. +In this example, the system has a 64-bit built-in `double` representation. The variable `f11` is initialized with the literal `double` value 11.1. Recall that built-in floating-point representations are based on successive binary fractional approximations. diff --git a/doc/tutorial_float_eg.qbk b/doc/tutorial_float_eg.qbk index 74c257e76..b7b891ceb 100644 --- a/doc/tutorial_float_eg.qbk +++ b/doc/tutorial_float_eg.qbk @@ -38,11 +38,11 @@ Typical output is: [endsect] [/section:caveats Caveats] -[section:jel Defining a Special Function.] +[section:jel Defining a Special Function] [JEL] -[endsect] [/section:jel Defining a Special Function.] +[endsect] [/section:jel Defining a Special Function] [section:nd Calculating a Derivative] diff --git a/doc/tutorial_fwd.qbk b/doc/tutorial_fwd.qbk index a553bfd18..de5309025 100644 --- a/doc/tutorial_fwd.qbk +++ b/doc/tutorial_fwd.qbk @@ -11,7 +11,7 @@ [section:fwd Forward Declarations] The header `` contains forward declarations for class `number` plus all of the -available backends in the this library: +available backends in this library: namespace boost { namespace multiprecision { diff --git a/doc/tutorial_gmp_float.qbk b/doc/tutorial_gmp_float.qbk index e359b67b9..6a9d9a0b0 100644 --- a/doc/tutorial_gmp_float.qbk +++ b/doc/tutorial_gmp_float.qbk @@ -25,8 +25,8 @@ }} // namespaces -The `gmp_float` back-end is used in conjunction with `number` : it acts as a thin wrapper around the [gmp] `mpf_t` -to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with +The `gmp_float` back-end is used in conjunction with `number`: it acts as a thin wrapper around the [gmp] `mpf_t` +to provide a real-number type that is a drop-in replacement for the native C++ floating-point types, but with much greater precision. Type `gmp_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or @@ -50,7 +50,7 @@ Things you should know when using this type: * Default constructed `gmp_float`s have the value zero (this is the [gmp] library's default behavior). * No changes are made to the [gmp] library's global settings, so this type can be safely mixed with existing [gmp] code. -* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware. +* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move-aware. * It is not possible to round-trip objects of this type to and from a string and get back exactly the same value. This appears to be a limitation of [gmp]. * Since the underlying [gmp] types have no notion of infinities or NaNs, care should be taken @@ -68,4 +68,4 @@ as a valid floating-point number. [mpf_eg] -[endsect] \ No newline at end of file +[endsect] diff --git a/doc/tutorial_gmp_int.qbk b/doc/tutorial_gmp_int.qbk index 74460f78e..65bbc6ac2 100644 --- a/doc/tutorial_gmp_int.qbk +++ b/doc/tutorial_gmp_int.qbk @@ -37,7 +37,7 @@ existing code that uses [gmp]. * Default constructed `gmp_int`s have the value zero (this is GMP's default behavior). * Formatted IO for this type does not support octal or hexadecimal notation for negative values, as a result performing formatted output on this type when the argument is negative and either of the flags -`std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown. +`std::ios_base::oct` or `std::ios_base::hex` are set will result in a `std::runtime_error` being thrown. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid integer. * Division by zero results in a `std::overflow_error` being thrown. diff --git a/doc/tutorial_import_export.qbk b/doc/tutorial_import_export.qbk index 94bfdb47e..10bfe68c0 100644 --- a/doc/tutorial_import_export.qbk +++ b/doc/tutorial_import_export.qbk @@ -77,7 +77,7 @@ that presents it in native order (see [@http://www.boost.org/doc/libs/release/li [note Note that this function is optimized for the case where the data can be `memcpy`ed from the source to the integer - in this case both -iterators much be pointers, and everything must be little-endian.] +iterators must be pointers, and everything must be little-endian.] [h4 Examples] diff --git a/doc/tutorial_interval_mpfi.qbk b/doc/tutorial_interval_mpfi.qbk index 7d3c995b4..7fb9a06c6 100644 --- a/doc/tutorial_interval_mpfi.qbk +++ b/doc/tutorial_interval_mpfi.qbk @@ -10,7 +10,7 @@ [section:interval Interval Number Types] -There is one currently only one interval number type supported - [mpfi]. +There is currently only one interval number type supported - [mpfi]. [section:mpfi mpfi_float] @@ -30,13 +30,13 @@ There is one currently only one interval number type supported - [mpfi]. }} // namespaces The `mpfi_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfi] `mpfi_t` -to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with +to provide a real-number type that is a drop-in replacement for the native C++ floating-point types, but with much greater precision and implementing interval arithmetic. Type `mpfi_float_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or at variable precision by setting the template argument to zero. The `typedef`s `mpfi_float_50`, `mpfi_float_100`, `mpfi_float_500`, `mpfi_float_1000` provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision -respectively. The `typedef mpfi_float` provides a variable precision type whose precision can be controlled via theF +respectively. The `typedef mpfi_float` provides a variable precision type whose precision can be controlled via the `number`s member functions. [note This type only provides `numeric_limits` support when the precision is fixed at compile time.] diff --git a/doc/tutorial_io.qbk b/doc/tutorial_io.qbk index c1ba4e19d..da4c32b45 100644 --- a/doc/tutorial_io.qbk +++ b/doc/tutorial_io.qbk @@ -50,7 +50,7 @@ so a reasonable test strategy is to use a large number of random values. The test at [@../../test/test_cpp_bin_float_io.cpp test_cpp_bin_float_io.cpp] allows any floating-point type to be ['round_tripped] using a wide range of fairly random values. -It also includes tests compared a collection of +It also includes tests comparing a collection of [@../../test/string_data.ipp stringdata] test cases in a file. [h4 Comparing with output using __fundamental types] @@ -102,7 +102,7 @@ So to conform to the C99 standard (incorporated by C++) Confusingly, Microsoft (and MinGW) do not conform to this standard and provide [*at least three digits], for example `1e+001`. So if you want the output to match that from -__fundamental floating-point types on compilers that use Microsofts runtime then use: +__fundamental floating-point types on compilers that use Microsoft's runtime then use: #define BOOST_MP_MIN_EXPONENT_DIGITS 3 diff --git a/doc/tutorial_logged_adaptor.qbk b/doc/tutorial_logged_adaptor.qbk index 43ab6fae1..292108b03 100644 --- a/doc/tutorial_logged_adaptor.qbk +++ b/doc/tutorial_logged_adaptor.qbk @@ -49,7 +49,7 @@ for the particular backend being observed. This type provides `numeric_limits` support whenever the template argument Backend does so. -Template alias `logged_adaptor_t` can be used as a shortcut for converting some instantiation of `number<>` to it's logged euqivalent. +Template alias `logged_adaptor_t` can be used as a shortcut for converting some instantiation of `number<>` to its logged equivalent. This type is particularly useful when combined with an interval number type - in this case we can use `log_postfix_event` to monitor the error accumulated after each operation. We could either set some kind of trap whenever the accumulated error diff --git a/doc/tutorial_mixed_precision.qbk b/doc/tutorial_mixed_precision.qbk index aaf1720cd..ae58bc2c3 100644 --- a/doc/tutorial_mixed_precision.qbk +++ b/doc/tutorial_mixed_precision.qbk @@ -97,7 +97,7 @@ There are three backends that define this trait by default: * __mpfr_float_backend's provided they are of the same precision. In addition, while this feature can be used with expression templates turned off, this feature minimises temporaries -and hence memory allocations when expression template are turned on. +and hence memory allocations when expression templates are turned on. By way of an example, consider the dot product of two vectors of __cpp_int's, our first, fairly trivial implementation might look like this: @@ -120,7 +120,7 @@ value vectors for random data with various bit counts: [table [[Bit Count][Allocations Count Version 1][Allocations Count Version 2][Allocations Count Version 3]] -[[32][1[footnote Here everything fits within __cpp_int's default internal cache, so no allocation are required.]][0][0]] +[[32][1[footnote Here everything fits within __cpp_int's default internal cache, so no allocation is required.]][0][0]] [[64][1001][1[footnote A single allocation for the return value.]][1]] [[128][1002][1][2]] [[256][1002][1][3[footnote Here the input data is such that more than one allocation is required for the temporary.]]] @@ -141,13 +141,13 @@ Timings for the three methods are as follows (MSVC-16.8.0, x64): ] As you can see, there is a sweet spot for middling-sized integers where we gain: if the values are small, then -__cpp_int's own internal cache is large enough anyway, and no allocation occur. Conversely, if the values are +__cpp_int's own internal cache is large enough anyway, and no allocation occurs. Conversely, if the values are sufficiently large, then the cost of the actual arithmetic dwarfs the memory allocation time. In this particular case, carefully writing the code (version 3) is clearly at least as good as using a separate type with a larger cache. However, there may be times when it's not practical to re-write existing code, purely to optimise it for the multiprecision use case. -A typical example where we can't rewrite our code to avoid unnecessary allocations, occurs when we're calling an +A typical example where we can't rewrite our code to avoid unnecessary allocations occurs when we're calling an external routine. For example the arc length of an ellipse with radii ['a] and ['b] is given by: [pre L(a, b) = 4aE(k)] @@ -187,7 +187,7 @@ non-allocating types so much, it does depend very much on the special function b The following backends have at least some direct support for mixed-precision arithmetic, and therefore avoid creating unnecessary temporaries when using the interfaces above. -Therefore when using these types it's more efficient to use mixed-precision arithmetic, +Therefore when using these types it's more efficient to use mixed-precision arithmetic than it is to explicitly cast the operands to the result type: __mpfr_float_backend, __mpf_float, __cpp_int. diff --git a/doc/tutorial_mpc_complex.qbk b/doc/tutorial_mpc_complex.qbk index 67ed3498d..dbea95727 100644 --- a/doc/tutorial_mpc_complex.qbk +++ b/doc/tutorial_mpc_complex.qbk @@ -26,7 +26,7 @@ }} // namespaces The `mpc_complex_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpc] `mpc_t` -to provide an real-number type that is a drop-in replacement for `std::complex`, but with +to provide a real-number type that is a drop-in replacement for `std::complex`, but with much greater precision. Type `mpc_complex_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or diff --git a/doc/tutorial_mpfr_float.qbk b/doc/tutorial_mpfr_float.qbk index ea060d79a..6c398579a 100644 --- a/doc/tutorial_mpfr_float.qbk +++ b/doc/tutorial_mpfr_float.qbk @@ -80,7 +80,7 @@ Things you should know when using this type: * No changes are made to [gmp] or [mpfr] global settings, so this type can coexist with existing [mpfr] or [gmp] code. * The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32. -* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware. +* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move-aware. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid floating-point number. * Division by zero results in an infinity. diff --git a/doc/tutorial_numeric_limits.qbk b/doc/tutorial_numeric_limits.qbk index 0ea0ca550..e93966f64 100644 --- a/doc/tutorial_numeric_limits.qbk +++ b/doc/tutorial_numeric_limits.qbk @@ -34,7 +34,7 @@ The chosen backend often determines how completely `std::numeric_limits` is avai Compiler options, processor type, and definition of macros or assembler instructions to control denormal numbers will alter the values in the tables given below. -[warning GMP's extendable floatin-point `mpf_t` does not have a concept of overflow: +[warning GMP's extendable floating-point `mpf_t` does not have a concept of overflow: operations that lead to overflow eventually run of out of resources and terminate with stack overflow (often after several seconds).] @@ -118,7 +118,7 @@ store a [*fixed precision], so half cents or pennies (or less) cannot be stored. The results of computations are rounded up or down, just like the result of integer division stored as an integer result. -There are number of proposals to +There are various proposals to [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3407.html add Decimal floating-point Support to C++]. @@ -158,7 +158,7 @@ Overflow of signed integers can be especially unexpected, possibly causing change of sign. Boost.Multiprecision integer type `cpp_int` is not modulo -because as an __arbitrary_precision types, +because as an __arbitrary_precision type, it expands to hold any value that the machine resources permit. However fixed precision __cpp_int's may be modulo if they are unchecked @@ -177,14 +177,14 @@ or 10 (for decimal types). [h4 digits] -The number of `radix` digits that be represented without change: +The number of `radix` digits that can be represented without change: * for integer types, the number of [*non-sign bits] in the significand. * for floating types, the number of [*radix digits] in the significand. -The values include any implicit bit, so for example, for the ubiquious +The values include any implicit bit, so for example, for the ubiquitous `double` using 64 bits -([@http://en.wikipedia.org/wiki/Double_precision_floating-point_format IEEE binary64 ]), +([@http://en.wikipedia.org/wiki/Double_precision_floating-point_format IEEE binary64]), `digits` == 53, even though there are only 52 actual bits of the significand stored in the representation. The value of `digits` reflects the fact that there is one implicit bit which is always set to 1. @@ -327,9 +327,9 @@ and references therein and [@https://arxiv.org/pdf/1310.8121.pdf Easy Accurate Reading and Writing of Floating-Point Numbers, Aubrey Jaffer (August 2018)]. -Microsoft VS2017 and other recent compilers, now use the +Microsoft VS2017 and other recent compilers now use the [@https://doi.org/10.1145/3192366.3192369 Ryu fast float-to-string conversion by Ulf Adams] -algorithm, claimed to be both exact and fast for 32 and 64-bit floating-point numbers. +algorithm, claimed to be both exact and fast for 32- and 64-bit floating-point numbers. ] [/note] [h4 round_style] @@ -382,7 +382,7 @@ gradual underflow, so that, if type T is `double`. A type may have any of the following `enum float_denorm_style` values: * `std::denorm_absent`, if it does not allow denormalized values. -(Always used for all integer and exact types). +(Always used for all integer and exact types.) * `std::denorm_present`, if the floating-point type allows denormalized values. *`std::denorm_indeterminate`, if indeterminate at compile time. @@ -391,9 +391,9 @@ A type may have any of the following `enum float_denorm_style` values: `bool std::numeric_limits::tinyness_before` `true` if a type can determine that a value is too small -to be represent as a normalized value before rounding it. +to be represented as a normalized value before rounding it. -Generally true for `is_iec559` floating-point __fundamantal types, +Generally true for `is_iec559` floating-point __fundamental types, but false for integer types. Standard-compliant IEEE 754 floating-point implementations may detect the floating-point underflow at three predefined moments: @@ -591,7 +591,7 @@ used thus: BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance); (There is also a version BOOST_CHECK_CLOSE using tolerance as a [*percentage] rather than a fraction; -usually the fraction version is simpler to use). +usually the fraction version is simpler to use.) [tolerance_2] @@ -607,7 +607,7 @@ For IEEE754 system (for which `std::numeric_limits::is_iec559 == true`) [@http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity positive and negative infinity] are assigned bit patterns for all defined floating-point types. -Confusingly, the string resulting from outputting this representation, is also +Confusingly, the string resulting from outputting this representation is also implementation-defined. And the string that can be input to generate the representation is also implementation-defined. For example, the output is `1.#INF` on Microsoft systems, but `inf` on most *nix platforms. @@ -615,7 +615,7 @@ For example, the output is `1.#INF` on Microsoft systems, but `inf` on most *nix This implementation-defined-ness has hampered use of infinity (and NaNs) but __Boost_Math and __Boost_Multiprecision work hard to provide a sensible representation for [*all] floating-point types, not just the __fundamental_types, -which with the use of suitable facets to define the input and output strings, makes it possible +which with the use of suitable facets to define the input and output strings makes it possible to use these useful features portably and including __Boost_Serialization. [h4 Not-A-Number NaN] @@ -631,11 +631,11 @@ provides an implementation-defined representation for NaN. result of an assignment or computation is meaningless. A typical example is `0/0` but there are many others. -NaNs may also be used, to represent missing values: for example, +NaNs may also be used to represent missing values: for example, these could, by convention, be ignored in calculations of statistics like means. Many of the problems with a representation for -[@http://en.wikipedia.org/wiki/NaN Not-A-Number] has hampered portable use, +[@http://en.wikipedia.org/wiki/NaN Not-A-Number] have hampered portable use, similar to those with infinity. [nan_1] diff --git a/doc/tutorial_random.qbk b/doc/tutorial_random.qbk index 8348734cf..195ebf452 100644 --- a/doc/tutorial_random.qbk +++ b/doc/tutorial_random.qbk @@ -14,7 +14,7 @@ Random numbers are generated in conjunction with Boost.Random. There is a single generator that supports generating random integers with large bit counts: [@http://www.boost.org/doc/html/boost/random/independent_bits_engine.html `independent_bits_engine`]. -This type can be used with either ['unbounded] integer types, or with ['bounded] (ie fixed precision) unsigned integers: +This type can be used with either ['unbounded] integer types, or with ['bounded] (i.e. fixed precision) unsigned integers: [random_eg1] @@ -41,7 +41,7 @@ with a multiprecision generator such as [@http://www.boost.org/doc/html/boost/ra Or to use [@http://www.boost.org/doc/html/boost/random/uniform_smallint.html `uniform_smallint`] or [@http://www.boost.org/doc/html/boost/random/random_number_generator.html `random_number_generator`] with multiprecision types. -floating-point values in \[0,1) are most easily generated using [@http://www.boost.org/doc/html/boost/random/generate_canonical.html `generate_canonical`], +Floating-point values in \[0,1) are most easily generated using [@http://www.boost.org/doc/html/boost/random/generate_canonical.html `generate_canonical`], note that `generate_canonical` will call the generator multiple times to produce the requested number of bits, for example we can use it with a regular generator like so: @@ -50,7 +50,7 @@ it with a regular generator like so: [random_eg3_out] Note however, the distributions do not invoke the generator multiple times to fill up the mantissa of a multiprecision floating-point type -with random bits. For these therefore, we should probably use a multiprecision generator (ie `independent_bits_engine`) in combination +with random bits. For these therefore, we should probably use a multiprecision generator (i.e. `independent_bits_engine`) in combination with the distribution: [random_eg4] @@ -59,7 +59,7 @@ with the distribution: And finally, it is possible to use the floating-point generators [@http://www.boost.org/doc/html/boost/random/lagged_fibonacci_01_engine.html `lagged_fibonacci_01_engine`] and [@http://www.boost.org/doc/html/boost/random/subtract_with_idp144360752.html `subtract_with_carry_01_engine`] directly with multiprecision floating-point types. -It's worth noting however, that there is a distinct lack of literature on generating high bit-count random numbers, and therefore a lack of "known good" parameters to +It's worth noting, however, that there is a distinct lack of literature on generating high bit-count random numbers, and therefore a lack of "known good" parameters to use with these generators in this situation. For this reason, these should probably be used for research purposes only: [random_eg5] diff --git a/doc/tutorial_rational.qbk b/doc/tutorial_rational.qbk index 022b4571f..e91fc0d9f 100644 --- a/doc/tutorial_rational.qbk +++ b/doc/tutorial_rational.qbk @@ -18,7 +18,7 @@ The following back-ends provide rational number arithmetic: [[`gmp_rational`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]] [[`tommath_rational`][boost/multiprecision/tommath.hpp][2][[tommath]][All C/C++ implementation that's Boost Software Licence compatible.][Slower than [gmp].]] [[`rational_adaptor`][boost/multiprecision/rational_adaptor.hpp][N/A][none][All C++ adaptor that allows any integer back-end type to be used as a rational type.][Requires an underlying integer back-end type.]] -[[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can used with any `number` integer type.][The expression templates used by `number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]] +[[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can be used with any `number` integer type.][The expression templates used by `number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]] ] [include tutorial_cpp_rational.qbk] diff --git a/doc/tutorial_tommath.qbk b/doc/tutorial_tommath.qbk index b3bcba07a..d298d2029 100644 --- a/doc/tutorial_tommath.qbk +++ b/doc/tutorial_tommath.qbk @@ -32,7 +32,7 @@ rather strange beast as it's a signed type that is not a 2's complement type. A operator`~` is deliberately not implemented for this type. * Formatted IO for this type does not support octal or hexadecimal notation for negative values, as a result performing formatted output on this type when the argument is negative and either of the flags -`std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown. +`std::ios_base::oct` and `std::ios_base::hex` is set will result in a `std::runtime_error` being thrown. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid integer. * Division by zero results in a `std::overflow_error` being thrown. diff --git a/doc/tutorial_tommath_rational.qbk b/doc/tutorial_tommath_rational.qbk index af54bc2b6..4e66844bf 100644 --- a/doc/tutorial_tommath_rational.qbk +++ b/doc/tutorial_tommath_rational.qbk @@ -23,7 +23,7 @@ The `tommath_rational` back-end is used via the typedef `boost::multiprecision:: `boost::rational` to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision. -The advantage of using this type rather than `boost::rational` directly, is that it is expression-template enabled, +The advantage of using this type rather than `boost::rational` directly is that it is expression-template enabled, greatly reducing the number of temporaries created in complex expressions. There are also non-member functions: @@ -35,12 +35,12 @@ which return the numerator and denominator of the number. Things you should know when using this type: -* Default constructed `tom_rational`s have the value zero (this the inherited Boost.Rational behavior). +* Default constructed `tom_rational`s have the value zero (this is the inherited Boost.Rational behavior). * Division by zero results in a `std::overflow_error` being thrown. * Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid rational number. * No changes are made to [tommath]'s global state, so this type can safely coexist with other [tommath] code. -* Performance of this type has been found to be pretty poor - this need further investigation - but it appears that Boost.Rational +* Performance of this type has been found to be pretty poor - this needs further investigation - but it appears that Boost.Rational needs some improvement in this area. [h5 Example:] diff --git a/doc/tutorial_variable_precision.qbk b/doc/tutorial_variable_precision.qbk index f54352fc6..73ba4fac7 100644 --- a/doc/tutorial_variable_precision.qbk +++ b/doc/tutorial_variable_precision.qbk @@ -3,7 +3,7 @@ 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). + http://www.boost.org/LICENSE_1_0.txt.) ] [section:variable Variable Precision Arithmetic] @@ -67,23 +67,23 @@ The enumerated values have the following meanings, with `preserve_related_precis [[preserve_target_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and then rounded to the precision of the target variable upon assignment. The precision of other types (including related or component types - see preserve_component_precision/preserve_related_precision) contained within the expression are ignored. - This option has the unfortunate side effect, that moves may become full deep copies.]] + This option has the unfortunate side effect that moves may become full deep copies.]] [[preserve_source_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment. The precision of other types (including related or component types - see preserve_component_precision/preserve_related_precision) contained within the expression are ignored. - Moves, are true moves not copies.]] + Moves are true moves, not copies.]] [[preserve_component_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment. If the expression contains component types then these are also considered when calculating the precision of the expression. Component types are the types which make up the two components of the number when dealing with interval or complex numbers. They are the same type as `Num::value_type`. - Moves, are true moves not copies.]] + Moves are true moves, not copies.]] [[preserve_related_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment. If the expression contains component types then these are also considered when calculating the precision of the expression. In addition to component types, all related types are considered when evaluating the precision of the expression. Related types are considered to be instantiations of the same template, but with different parameters. So for example `mpfr_float_100` would be a related type to `mpfr_float`, and all expressions - containing an `mpfr_float_100` variable would have at least 100 decimal digits of precision when evaluated as an `mpfr_float` expression. Moves, are true moves not copies.]] + containing an `mpfr_float_100` variable would have at least 100 decimal digits of precision when evaluated as an `mpfr_float` expression. Moves are true moves, not copies.]] [[preserve_all_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment. In addition to component and related types, all types are considered when evaluating the precision of the expression. For example, if the expression contains an `mpz_int`, then the precision of the expression will be sufficient to store all of the digits in the integer unchanged. - This option should generally be used with extreme caution, as it can easily cause unintentional precision inflation. Moves, are true moves not copies.]] + This option should generally be used with extreme caution, as it can easily cause unintentional precision inflation. Moves are true moves, not copies.]] ] Note how the values `preserve_source_precision`, `preserve_component_precision`, @@ -93,7 +93,7 @@ the precision of an expression: [table [[Value][Considers types (lowest in hierarchy first, each builds on the one before)]] [[preserve_source_precision][Considers types the same as the result in the expression only.]] -[[preserve_component_precision][Also considers component types, ie `Num::value_type`.]] +[[preserve_component_precision][Also considers component types, i.e. `Num::value_type`.]] [[preserve_related_precision][Also considers all instantiations of the backend-template, not just the same type as the result.]] [[preserve_all_precision][Considers everything, including completely unrelated types such as (possibly arbitrary precision) integers.]] ] diff --git a/doc/tutorial_visualizers.qbk b/doc/tutorial_visualizers.qbk index 78a836453..e9489eced 100644 --- a/doc/tutorial_visualizers.qbk +++ b/doc/tutorial_visualizers.qbk @@ -12,7 +12,7 @@ [important This section is seriously out of date compared to recent Visual C++ releases. A modernization of Multiprecision's visualizers is planned for Visual Studio 2022 (and beyond). The legacy description has been maintained and is provided below.] -Let's face it debugging multiprecision numbers is challenging - simply because we can't easily inspect the value of the numbers. +Let's face it, debugging multiprecision numbers is challenging - simply because we can't easily inspect the value of the numbers. Visual C++ provides a partial solution in the shape of "visualizers" which provide improved views of complex data structures. Previously, there was preliminary support for visualizers within older versions of Visual Studio. diff --git a/example/big_seventh.cpp b/example/big_seventh.cpp index 8bfe08c95..652a50dfc 100644 --- a/example/big_seventh.cpp +++ b/example/big_seventh.cpp @@ -71,7 +71,7 @@ allows us to define variables with 50 decimal digit precision just like __fundam 0.14285714285714285714285714285714285714285714285714 -We can also use Boost.Math __math_constants like [pi], +We can also use __math_constants like [pi], guaranteed to be initialized with the very last bit of precision for the floating-point type. */ std::cout << "pi = " << boost::math::constants::pi() << std::endl; @@ -140,7 +140,7 @@ but if one is implementing a formula involving a fraction from integers, including decimal fractions like 1/10, 1/100, then comparison with other computations like __WolframAlpha will reveal differences whose cause may be perplexing. -To get as precise-as-possible decimal fractions like 1.234, we can write +To get as-precise-as-possible decimal fractions like 1.234, we can write */ const cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000); // Construct from a fraction. diff --git a/example/cpp_int_import_export.cpp b/example/cpp_int_import_export.cpp index d1aa78a18..da317b655 100644 --- a/example/cpp_int_import_export.cpp +++ b/example/cpp_int_import_export.cpp @@ -28,7 +28,7 @@ int main() using boost::multiprecision::cpp_int; // Create a cpp_int with just a couple of bits set: cpp_int i; - bit_set(i, 5000); // set the 5000'th bit + bit_set(i, 5000); // set the 5000th bit bit_set(i, 200); bit_set(i, 50); // export into 8-bit unsigned values, most significant bit first: diff --git a/example/floating_point_examples.cpp b/example/floating_point_examples.cpp index 1e338511d..14bbce54c 100644 --- a/example/floating_point_examples.cpp +++ b/example/floating_point_examples.cpp @@ -121,8 +121,8 @@ Which outputs: [pre 9.82266396479604757017335009796882833995903762577173e-01] -Now that we've seen some non-template examples, lets repeat the code again, but this time as a template -that can be called either with a builtin type (`float`, `double` etc), or with a multiprecision type: +Now that we've seen some non-template examples, let's repeat the code again, but this time as a template +that can be called either with a builtin type (`float`, `double` etc.), or with a multiprecision type: */ diff --git a/example/gauss_laguerre_quadrature.cpp b/example/gauss_laguerre_quadrature.cpp index d6a95a19b..6ff8dcae3 100644 --- a/example/gauss_laguerre_quadrature.cpp +++ b/example/gauss_laguerre_quadrature.cpp @@ -18,7 +18,7 @@ // of this example) could be used for smaller arguments. // This example has been tested with decimal digits counts -// ranging from 21...301, by adjusting the parameter +// ranging from 21 to 301, by adjusting the parameter // local::my_digits10 at compile time. // References: diff --git a/example/integer_examples.cpp b/example/integer_examples.cpp index e6086162f..7c1770002 100644 --- a/example/integer_examples.cpp +++ b/example/integer_examples.cpp @@ -52,12 +52,12 @@ void print_factorials() factorial *= i; } // - // Lets see how many digits the largest factorial was: + // Let's see how many digits the largest factorial was: unsigned digits = results.back().str().size(); // // Now print them out, using right justification, while we're at it // we'll indicate the limit of each integer type, so begin by defining - // the limits for 16, 32, 64 etc bit integers: + // the limits for 16, 32, 64 etc. bit integers: cpp_int limits[] = { (cpp_int(1) << 16) - 1, (cpp_int(1) << 32) - 1, diff --git a/example/mpfr_precision.cpp b/example/mpfr_precision.cpp index 179ea763e..e3002bfdb 100644 --- a/example/mpfr_precision.cpp +++ b/example/mpfr_precision.cpp @@ -12,12 +12,12 @@ beta distribution to an absurdly high precision and compare the accuracy and times taken for various methods. That is, we want to calculate the value of `x` for which ['I[sub x](a, b) = 0.5]. -Ultimately we'll use Newtons method and set the precision of +Ultimately we'll use Newton's method and set the precision of mpfr_float to have just enough digits at each iteration. -The full source of the this program is in [@../../example/mpfr_precision.cpp] +The full source of this program is in [@../../example/mpfr_precision.cpp]. -We'll skip over the #includes and using declations, and go straight to +We'll skip over the #includes and using declarations, and go straight to some support code, first off a simple stopwatch for performance measurement: */ @@ -106,11 +106,11 @@ We'll begin with a reference method that simply calls the Boost.Math function `i full working precision of the arguments throughout. Our reference function takes 3 arguments: * The 2 parameters `a` and `b` of the beta distribution, and -* The number of decimal digits precision to achieve in the result. +* the number of decimal digits precision to achieve in the result. We begin by setting the default working precision to that requested, and then, since we don't know where our arguments `a` and `b` have been or what precision they have, we make a copy of them - note that since -copying also copies the precision as well as the value, we have to set the precision expicitly with a +copying also copies the precision as well as the value, we have to set the precision explicitly with a second argument to the copy. Then we can simply return the result of `ibeta_inv`: */ mpfr_float beta_distribution_median_method_1(mpfr_float const& a_, mpfr_float const& b_, unsigned digits10) @@ -120,8 +120,8 @@ mpfr_float beta_distribution_median_method_1(mpfr_float const& a_, mpfr_float co return ibeta_inv(a, b, half); } /*` -You be wondering why we needed to change the precision of our variables `a` and `b` as well as setting the default - -there are in fact two ways in which this can go wrong if we don't do that: +You may be wondering why we needed to change the precision of our variables `a` and `b` as well as setting the +default - there are in fact two ways in which this can go wrong if we don't do that: * The variables have too much precision - this will cause all arithmetic operations involving those types to be promoted to the higher precision wasting precious calculation time. diff --git a/example/numeric_limits_snips.cpp b/example/numeric_limits_snips.cpp index 4f4d06cad..b2fc56a1a 100644 --- a/example/numeric_limits_snips.cpp +++ b/example/numeric_limits_snips.cpp @@ -99,7 +99,7 @@ BOOST_AUTO_TEST_CASE(test_numeric_limits_snips) double write = 2./3; // Any arbitrary value that cannot be represented exactly. double read = 0; std::stringstream s; - s.precision(std::numeric_limits::digits10); // or `float64_t` for 64-bit IEE754 double. + s.precision(std::numeric_limits::digits10); // or `float64_t` for 64-bit IEEE 754 double. s << write; s >> read; if(read != write) @@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE(test_numeric_limits_snips) } { //[max_digits10_4 -/*`and similarly for a much higher precision type: +/*`And similarly for a much higher precision type: */ using namespace boost::multiprecision; @@ -392,7 +392,7 @@ so the default expression template parameter has been replaced by `et_off`.] cpp_bin_float_quad expected = NaN; cpp_bin_float_quad calculated = 2 * NaN; - // Comparisons of NaN's always fail: + // Comparisons of NaNs always fail: bool b = expected == calculated; std::cout << b << std::endl; BOOST_CHECK_NE(expected, expected); @@ -445,7 +445,7 @@ Then we can equally well use a multiprecision type cpp_bin_float_quad: infinity output was inf infinity input was inf `` -Similarly we can do the same with NaN (except that we cannot use `assert` (because any comparisons with NaN always return false). +Similarly we can do the same with NaN (except that we cannot use `assert` (because any comparisons with NaN always return false)). */ { std::locale old_locale; diff --git a/example/random_snips.cpp b/example/random_snips.cpp index e295564b2..6f3ce88d8 100644 --- a/example/random_snips.cpp +++ b/example/random_snips.cpp @@ -195,7 +195,7 @@ void t4() using namespace boost::multiprecision; using namespace boost::random; // - // Generate some distruted values: + // Generate some distributed values: // uniform_real_distribution ur(-20, 20); gamma_distribution gd(20); @@ -277,7 +277,7 @@ void t5() // Generate some multiprecision values, note that the generator is so large // that we have to allocate it on the heap, otherwise we may run out of // stack space! We could avoid this by using a floating point type which - // allocates it's internal storage on the heap - cpp_bin_float will do + // allocates its internal storage on the heap - cpp_bin_float will do // this with the correct template parameters, as will the GMP or MPFR // based reals. // diff --git a/example/scoped_precision_example.cpp b/example/scoped_precision_example.cpp index e47766e73..9f52695f7 100644 --- a/example/scoped_precision_example.cpp +++ b/example/scoped_precision_example.cpp @@ -21,14 +21,14 @@ can be displayed in your debugger of choice: using mp_t = boost::multiprecision::debug_adaptor_t; /*` -Our first example will investigate calculating the Bessel J function via it's well known +Our first example will investigate calculating the Bessel J function via its well known series representation: [$../bessel2.svg] This simple series suffers from catastrophic cancellation error near the roots of the function, so we'll investigate slowly increasing the precision of -the calculation until we get the result to N-decimal places. We'll begin by defining +the calculation until we get the result to N decimal places. We'll begin by defining a function to calculate the series for Bessel J, the details of which we'll leave in the source code: */ @@ -158,11 +158,11 @@ mp_t Bessel_J_to_precision(mp_t v, mp_t x, unsigned digits10) } // // We now have an accurate result, but it may have too many digits, - // so lets round the result to the requested precision now: + // so let's round the result to the requested precision now: // result.precision(saved_digits10); // - // To maintain uniform precision during function return, lets + // To maintain uniform precision during function return, let's // reset the default precision now: // scoped.reset(saved_digits10); @@ -173,7 +173,7 @@ mp_t Bessel_J_to_precision(mp_t v, mp_t x, unsigned digits10) So far, this is all well and good, but there is still a potential trap for the unwary here, when the function returns the variable [/result] may be copied/moved either once or twice depending on whether the compiler implements the named-return-value optimisation. And since this -all happens outside the scope of this function, the precision of the returned value may get unexpected +all happens outside the scope of this function, the precision of the returned value may get unexpectedly changed - and potentially with different behaviour once optimisations are turned on! To prevent these kinds of unintended consequences, a function returning a value with specified precision @@ -328,7 +328,7 @@ mp_t reduce_n_pi(const mp_t& arg) scope_2.reset(boost::multiprecision::variable_precision_options::preserve_target_precision); mp_t result = reduced; // - // As with previous examples, returning the result may create temporaries, so lets + // As with previous examples, returning the result may create temporaries, so let's // make sure that we preserve the precision of result. Note that this isn't strictly // required if the calling context is always of uniform precision, but we can't be sure // of our calling context: From 2b1361025a219b51a72b17046bc57519c61735bd Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 18 Aug 2025 13:18:05 +0200 Subject: [PATCH 054/114] Update docs --- doc/tutorial_cpp_double_fp_backend.qbk | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/tutorial_cpp_double_fp_backend.qbk b/doc/tutorial_cpp_double_fp_backend.qbk index b564e7f1c..f3149d03c 100644 --- a/doc/tutorial_cpp_double_fp_backend.qbk +++ b/doc/tutorial_cpp_double_fp_backend.qbk @@ -67,14 +67,14 @@ Things you should know when using the `cpp_double_fp_backend` types: * Although the types are created from two individual IEEE floating-point components, they specifically and clearly are not IEEE types in their composite forms. * As a result these types can behave subtly differently from IEEE floating-point types. -* The types can not be used with compiler variations of _fast_-_math_ (i.e., `-ffast-math` on GCC can not be used and `/fp:precise` is mandatory on MSVC compilers). This is because the algorithms (particularly those for addition, subtraction, multiplication and square root) rely on precise floating-point rounding. +* The types can not be used with certain compiler variations of _fast_-_math_. On GCC/clang, for instance, `-ffast-math` can not be used (use either the default or explicitly set `-fno-fast-math`). On MSVC `/fp:fast` can not be used and `/fp:precise` (the default) is mandatory on MSVC compilers. This is because the algorithms, in particular those for addition, subtraction, multiplication, division and square root, rely on precise floating-point rounding. * The composite types are not as precise as their constituents. For information on error-bounds, see Joldes et al. in the references below. * There are `std::numeric_limits` specializations for these types. * Large parts (but not all) of the `cpp_double_fp_backend` implementation are `constexpr`. Future evolution is anticipated to make this library entirely `constexpr`. * Conversions to and from string internally use an intermediate `cpp_bin_float` value (which is a bit awkward may be eliminated in future refinements). -The `cpp_double_fp_backend` back-end has been inspired by original works and types such as the historical `doubledouble` -and more. These include the following: +The `cpp_double_fp_backend` back-end has been inspired by original works and types. +These include the historical `doubledouble` and more, as listed below. * K. Briggs, the `doubledouble` library, 1998. * V. Shoup, the class `quad_float` in the NTL number-theory library [@https://libntl.org]. From b40b35e20e5f4abd3a94ecb6a28e34c330d71ad3 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 25 Aug 2025 18:08:46 +0200 Subject: [PATCH 055/114] Finish most or nearly all of constexpr-ness --- .../cpp_df_qf_detail_ccmath_fabs.hpp | 2 +- .../cpp_df_qf_detail_ccmath_floor.hpp | 93 ++++++++- .../cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 56 ++--- .../cpp_df_qf_detail_ccmath_fpclassify.hpp | 11 +- .../cpp_df_qf_detail_ccmath_frexp.hpp | 71 ++++++- .../cpp_df_qf_detail_ccmath_isnan.hpp | 2 +- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 57 ++++-- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 148 +++++++++++++- .../cpp_df_qf_detail_ccmath_sqrt.hpp | 34 ++-- .../cpp_df_qf/cpp_df_qf_detail_constants.hpp | 30 +-- .../boost/multiprecision/cpp_double_fp.hpp | 192 ++++++++---------- test/math/test_bessel_j.cpp | 15 +- test/test_arithmetic_df.cpp | 35 +++- 13 files changed, 510 insertions(+), 236 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp index cfd3b5260..f71ef3501 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp @@ -14,7 +14,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto fabs(Real x) -> Real +constexpr auto fabs(Real x) noexcept -> Real { return (cpp_df_qf_detail::ccmath::isnan(x)) ? cpp_df_qf_detail::ccmath::numeric_limits::quiet_NaN() : (x == static_cast(-0)) ? static_cast(0) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp index 4df2f46a3..84d5d66c0 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp @@ -8,20 +8,90 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP +#include + #include #include namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { +namespace unsafe { + namespace detail { -template -constexpr auto floor_impl(T x) -> T +template +constexpr auto floor_pos_impl(Real arg) noexcept -> Real { - // Default to the regular floor function. - using std::floor; + constexpr auto + max_comp_val + { + Real(1) / ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::epsilon() + }; + + if (arg >= max_comp_val) + { + return arg; + } + + Real result { 1 }; + + if(result <= arg) + { + while(result < arg) + { + result *= 2; + } - return floor(x); + while(result > arg) + { + --result; + } + + return result; + } + else + { + return Real(0); + } +} + +template +constexpr auto floor_neg_impl(Real arg) noexcept -> Real +{ + Real result { -1 }; + + if(result > arg) + { + while(result > arg) + { + result *= 2; + } + + while(result < arg) + { + ++result; + } + + if(result != arg) + { + --result; + } + } + + return result; +} + +template +constexpr auto floor_impl(Real arg) noexcept -> Real +{ + if(arg > 0) + { + return floor_pos_impl(arg); + } + else + { + return floor_neg_impl(arg); + } } } // namespace detail @@ -29,9 +99,20 @@ constexpr auto floor_impl(T x) -> T template constexpr auto floor(Real x) -> Real { - return cpp_df_qf_detail::ccmath::detail::floor_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::floor_impl(x); + } + else + { + using std::floor; + + return floor(x); + } } +} // namespace unsafe + } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index f7117c8c2..38f265628 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -17,41 +17,43 @@ namespace unsafe { namespace detail { -template -constexpr auto fma_impl(T x, T y, T z) noexcept -> T +template +constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept { - // Default to the written-out operations ... - // ... and hope the compiler chooses FMA if available). - + #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) + BOOST_IF_CONSTEXPR (std::is_same_v) + { + return __builtin_fmaf(x, y, z); + } + else BOOST_IF_CONSTEXPR (std::is_same_v) + { + return __builtin_fma(x, y, z); + } + else BOOST_IF_CONSTEXPR (std::is_same_v) + { + return __builtin_fmal(x, y, z); + } + #endif + + // If we can't use compiler intrinsics hope that -fma flag optimizes this call to fma instruction return (x * y) + z; } -#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) -template <> -constexpr auto fma_impl(float x, float y, float z) noexcept -> float -{ - return __builtin_fmaf(x, y, z); -} - -template <> -constexpr auto fma_impl(double x, double y, double z) noexcept -> double -{ - return __builtin_fma(x, y, z); -} - -template <> -constexpr auto fma_impl(long double x, long double y, long double z) noexcept -> long double -{ - return __builtin_fmal(x, y, z); -} -#endif - } // namespace detail template -constexpr auto fma(Real x, Real y, Real z) noexcept -> Real +constexpr auto fma(Real x, Real y, Real z) -> Real { - return detail::fma_impl(x, y, z); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::fma_impl(x, y, z); + } + else + { + using std::fma; + + return fma(x, y, z); + } } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp index 7824e99ad..d378094d5 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp @@ -11,13 +11,14 @@ #include #include #include +#include #include namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -template -constexpr auto fpclassify(T x) -> int +template +constexpr auto fpclassify(Real x) noexcept -> int { if ((::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::isnan)(x)) { @@ -29,13 +30,13 @@ constexpr auto fpclassify(T x) -> int } else { - const T fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; + const Real fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; - if (fabs_x == T(0)) + if (fabs_x == Real(0)) { return FP_ZERO; } - else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) + else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) { return FP_SUBNORMAL; } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp index 2ca53f32c..20ac79cca 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp @@ -13,16 +13,50 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace detail -{ +namespace unsafe { + +namespace detail { -template -constexpr auto frexp_impl(T arg, int* expptr) -> T +template +constexpr auto frexp_impl(Real arg, int* expptr) noexcept -> Real { - // Default to the regular frexp function. - using std::frexp; + const bool negative_arg { (arg < static_cast(0)) }; + + Real f { negative_arg ? -arg : arg }; + + int e2 { }; + + constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; + + while (f >= two_pow_16_plus) + { + f = f / two_pow_16_plus; + e2 += 16; + } + + constexpr Real two_pow_16_minus { static_cast(0.0000152587890625L) }; - return frexp(arg, expptr); + while (f <= two_pow_16_minus) + { + f = f * two_pow_16_plus; + e2 -= 16; + } + + while(f >= static_cast(INT8_C(1))) + { + f = f / static_cast(INT8_C(2)); + ++e2; + } + + while(f < static_cast(0.5L)) + { + f = f * static_cast(INT8_C(2)); + --e2; + } + + *expptr = e2; + + return ((!negative_arg) ? f : -f); } } // namespace detail @@ -30,9 +64,30 @@ constexpr auto frexp_impl(T arg, int* expptr) -> T template constexpr auto frexp(Real arg, int* expptr) -> Real { - return detail::frexp_impl(arg, expptr); + if (BOOST_MP_IS_CONST_EVALUATED(arg)) + { + if (arg == static_cast(0)) + { + *expptr = 0; + + return arg; + } + else + { + return detail::frexp_impl(arg, expptr); + } + } + else + { + // Default to the regular frexp function. + using std::frexp; + + return frexp(arg, expptr); + } } +} // namespace unsafe + } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FREXP_2023_01_07_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp index 468a97b97..4e45ff60f 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp @@ -11,7 +11,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto isnan(FloatingPointType x) -> bool +constexpr auto isnan(FloatingPointType x) noexcept -> bool { return (x != x); } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index da2510969..0f45822ee 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -13,42 +13,57 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { +namespace unsafe { + namespace detail { -template -constexpr auto ldexp_impl(T arg, int expval) -> T +template +constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real { - // Default to the regular ldexp function. - using std::ldexp; + constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; - return ldexp(arg, expval); -} + while(expval > 16) + { + arg *= two_pow_16_plus; + expval -= 16; + } -} // Namespace detail + while(expval < -16) + { + arg /= two_pow_16_plus; + expval += 16; + } -template -constexpr auto ldexp(Real arg, int expval) -> Real -{ - return detail::ldexp_impl(arg, expval); + while(expval > 0) + { + arg *= 2; + --expval; + } + + while(expval < 0) + { + arg /= 2; + ++expval; + } + + return arg; } -namespace unsafe { +} // Namespace detail template -constexpr auto ldexp(Real arg, int exp) noexcept -> Real +constexpr auto ldexp(Real arg, int expval) -> Real { - while(exp > 0) + if (BOOST_MP_IS_CONST_EVALUATED(x)) { - arg *= 2; - --exp; + return detail::ldexp_impl(arg, expval); } - while(exp < 0) + else { - arg /= 2; - ++exp; - } + using std::ldexp; - return arg; + return ldexp(arg, expval); + } } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 64cd301ed..3846fe4a2 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -8,20 +8,145 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP +#include +#include + #include #include +#if (defined(__GNUC__) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) +// +// This is the only way we can avoid +// warning: non-standard suffix on floating constant [-Wpedantic] +// when building with -Wall -pedantic. Neither __extension__ +// nor #pragma diagnostic ignored work :( +// +#pragma GCC system_header +#endif + namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { +namespace unsafe { + namespace detail { -template -constexpr auto log_impl(T x) -> T +template +constexpr auto exp_impl(Real x) noexcept -> Real { - // Default to the regular log function. - using std::log; + constexpr int + my_digits_10 + { + ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits10 + }; - return log(x); + constexpr int + loop_count + { + my_digits_10 < 8 ? 7 + : my_digits_10 < 16 ? 15 + : my_digits_10 < 20 ? 19 + : 33 + }; + + // Scale the argument with a single factor of 2. + // Then square the result upon return. + x /= 2; + + // Perform a simple Taylor series of the exponent function. + Real term { x }; + Real sum { Real { 1 } + term }; + + for (int loop_index { INT8_C(2) }; loop_index < loop_count; ++loop_index) + { + term *= x; + term /= static_cast(loop_index); + sum += term; + } + + // Scale the result. + return sum * sum; +} + +template +constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54), Real>::type +{ + // PadeApproximant[Log[x], {x, 1, {8, 8}}] + // FullSimplify[%] + + const Real + top + { + ((static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(761.0L) + x * (static_cast(28544.0L) + x * (static_cast(209305.0L) + x * (static_cast(423680.0L) + x * (static_cast(209305.0L) + x * (static_cast(28544.0L) + static_cast(761.0L) * x))))))) + }; + + const Real + bot + { + (static_cast(140.0L) * (static_cast(1.0L) + x * (static_cast(64.0L) + x * (static_cast(784.0L) + x * (static_cast(3136.0L) + x * (static_cast(4900.0L) + x * (static_cast(3136.0L) + x * (static_cast(784.0L) + x * (static_cast(64.0L) + x))))))))) + }; + + return top / bot; +} + +template +constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(!(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54)), Real>::type +{ + // PadeApproximant[Log[x], {x, 1, {16, 16}}] + // FullSimplify[%] + + const Real + top + { + (static_cast(17.0L) * (static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(143327.0L) + x * (static_cast(25160192.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(1923749922816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(25160192.0L) + static_cast(143327.0L) * x))))))))))))))) + }; + + const Real + bot + { + (static_cast(360360.0L) * (static_cast(1.0L) + x * (static_cast(256.0L) + x * (static_cast(14400.0L) + x * (static_cast(313600.0L) + x * (static_cast(3312400.0L) + x * (static_cast(19079424.0L) + x * (static_cast(64128064.0L) + x * (static_cast(130873600.0L) + x * (static_cast(165636900.0L) + x * (static_cast(130873600.0L) + x * (static_cast(64128064.0L) + x * (static_cast(19079424.0L) + x * (static_cast(3312400.0L) + x * (static_cast(313600.0L) + x * (static_cast(14400.0L) + x * (static_cast(256.0L) + x))))))))))))))))) + }; + + return top / bot; +} + +// N[Log[2], 101] +// 0.69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641868754 + +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 24), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 53), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 64), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +#if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068Q); } +#else +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +#endif + +template +constexpr auto log_impl(Real x) noexcept -> Real +{ + int n2 { }; + + Real x2 { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::unsafe::frexp(x, &n2) }; + + if (x2 > static_cast(0.9L)) + { + x2 /= 2; + + ++n2; + } + + Real s { log_impl_pade(x2) }; + + Real E { exp_impl(s) }; + + // Do one single step of Newton-Raphson iteration. + s = s + ((x2 - E) / E); + + Real xn2 { static_cast(n2) * constant_ln_two() }; + + s += xn2; + + return s; } } // namespace detail @@ -29,9 +154,20 @@ constexpr auto log_impl(T x) -> T template constexpr auto log(Real x) -> Real { - return cpp_df_qf_detail::ccmath::detail::log_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::log_impl(x); + } + else + { + using std::log; + + return log(x); + } } +} // namespace unsafe + } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 381570b91..29d06eb2c 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -13,25 +13,6 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace detail { - -template -constexpr auto sqrt_impl(T x) -> T -{ - // Default to the regular sqrt function. - using std::sqrt; - - return sqrt(x); -} - -} // namespace detail - -template -constexpr auto sqrt(Real x) -> Real -{ - return cpp_df_qf_detail::ccmath::detail::sqrt_impl(x); -} - namespace unsafe { namespace detail { @@ -39,7 +20,7 @@ namespace detail { template constexpr auto sqrt_impl_2(Real x, Real s, Real s2) noexcept -> Real { - return !(s < s2) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s); + return ((!(s < s2)) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s)); } template @@ -57,9 +38,18 @@ constexpr auto sqrt_impl(Real x) noexcept -> Real } // namespace detail template -constexpr auto sqrt(Real x) noexcept -> Real +constexpr auto sqrt(Real x) -> Real { - return detail::sqrt_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::sqrt_impl(x); + } + else + { + using std::sqrt; + + return sqrt(x); + } } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp index fed468273..b4994a92a 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp @@ -32,13 +32,13 @@ // 3.14159265358979323851281, -5.01655761266833202345176e-20 // 3.14159265358979323846264338327950279748, 8.67181013012378102479704402604335225411e-35 - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } #else - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } #endif // N[Log[2], 101] @@ -49,13 +49,13 @@ // 0.69314718055994530942869, -1.14583527267987328094768e-20 // 0.693147180559945309417232121458176575084, -7.00813947454958516341266200877162272784e-36 - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } #else - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } #endif // N[Exp[1], 101] @@ -66,13 +66,13 @@ // 2.71828182845904523521133, 1.4895979785582304563159e-19 // 2.71828182845904523536028747135266231436, 1.83398825226506410712297736767396397644e-34 - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } + template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } + template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } + template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } #else - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } #endif } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index befcd5f43..a92cff558 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -739,9 +739,9 @@ class cpp_double_fp_backend // Handle overflow by scaling down (and then back up) with the split. hc = - cpp_df_qf_detail::ccmath::ldexp + cpp_df_qf_detail::ccmath::unsafe::ldexp ( - C - float_type { C - cpp_df_qf_detail::ccmath::ldexp(C, -cpp_df_qf_detail::split_maker::n_shl) }, + C - float_type { C - cpp_df_qf_detail::ccmath::unsafe::ldexp(C, -cpp_df_qf_detail::split_maker::n_shl) }, cpp_df_qf_detail::split_maker::n_shl ); } @@ -759,9 +759,9 @@ class cpp_double_fp_backend // Handle overflow by scaling down (and then back up) with the split. hv = - cpp_df_qf_detail::ccmath::ldexp + cpp_df_qf_detail::ccmath::unsafe::ldexp ( - v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, + v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, cpp_df_qf_detail::split_maker::n_shl ); } @@ -1025,6 +1025,54 @@ class cpp_double_fp_backend return cpp_double_fp_backend(static_cast(HUGE_VAL), float_type { 0.0F }); // conversion from double infinity OK } + static constexpr auto my_value_logmax() noexcept -> cpp_double_fp_backend + { + // Here, we note that max is composed of (first + second), + // which we refactor as first * (1 + second / first). + + // We approximate log(first * (1 + second / first)) with + // log(first) + log(1 + second/first), and use an order-2 + // approximation for the second logarithm. + + constexpr float_type my_a { my_value_max().my_first() }; + constexpr float_type my_b { my_value_max().my_second() }; + + constexpr float_type dx { my_b / my_a }; + + constexpr cpp_double_fp_backend + my_value_logmax_constexpr + { + cpp_double_fp_backend { cpp_df_qf_detail::ccmath::unsafe::log(my_a) } + + cpp_double_fp_backend { dx * (static_cast(1.0F) - dx / static_cast(2.0F)) } + }; + + return my_value_logmax_constexpr; + } + + static constexpr auto my_value_logmin() noexcept -> cpp_double_fp_backend + { + // Here, we note that min is composed of (first + second), + // which we refactor as first * (1 + second / first). + + // We approximate log(first * (1 + second / first)) with + // log(first) + log(1 + second/first), and use an order-2 + // approximation for the second logarithm. + + constexpr float_type my_a { my_value_min().my_first() }; + constexpr float_type my_b { my_value_min().my_second() }; + + constexpr float_type dx { my_b / my_a }; + + constexpr cpp_double_fp_backend + my_value_logmin_constexpr + { + cpp_double_fp_backend { cpp_df_qf_detail::ccmath::unsafe::log(my_a) } + + cpp_double_fp_backend { dx * (static_cast(1.0F) - dx / static_cast(2.0F)) } + }; + + return my_value_logmin_constexpr; + } + private: rep_type data; @@ -1051,9 +1099,9 @@ class cpp_double_fp_backend { // Handle overflow by scaling down (and then back up) with the split. - C = data.first - cpp_df_qf_detail::ccmath::ldexp(data.first, -cpp_df_qf_detail::split_maker::n_shl); + C = data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(data.first, -cpp_df_qf_detail::split_maker::n_shl); - hu = cpp_df_qf_detail::ccmath::ldexp(data.first - C, cpp_df_qf_detail::split_maker::n_shl); + hu = cpp_df_qf_detail::ccmath::unsafe::ldexp(data.first - C, cpp_df_qf_detail::split_maker::n_shl); } else { @@ -1085,9 +1133,9 @@ class cpp_double_fp_backend { // Handle overflow by scaling down (and then back up) with the split. - c = v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl); + c = v.data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl); - hv = cpp_df_qf_detail::ccmath::ldexp(v.data.first - c, cpp_df_qf_detail::split_maker::n_shl); + hv = cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first - c, cpp_df_qf_detail::split_maker::n_shl); } else { @@ -1326,8 +1374,8 @@ constexpr auto eval_frexp(cpp_double_fp_backend& result, cons int expptr { }; - const local_float_type fhi { cpp_df_qf_detail::ccmath::frexp(a.rep().first, &expptr) }; - const local_float_type flo { cpp_df_qf_detail::ccmath::ldexp(a.rep().second, -expptr) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::frexp(a.rep().first, &expptr) }; + const local_float_type flo { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.rep().second, -expptr) }; if (v != nullptr) { @@ -1343,8 +1391,8 @@ constexpr auto eval_ldexp(cpp_double_fp_backend& result, cons using local_backend_type = cpp_double_fp_backend; using local_float_type = typename local_backend_type::float_type; - const local_float_type fhi { cpp_df_qf_detail::ccmath::ldexp(a.crep().first, v) }; - const local_float_type flo { cpp_df_qf_detail::ccmath::ldexp(a.crep().second, v) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.crep().first, v) }; + const local_float_type flo { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.crep().second, v) }; result.rep() = local_backend_type::arithmetic::normalize(fhi, flo); } @@ -1355,7 +1403,7 @@ constexpr auto eval_floor(cpp_double_fp_backend& result, cons using local_backend_type = cpp_double_fp_backend; using local_float_type = typename local_backend_type::float_type; - const local_float_type fhi { cpp_df_qf_detail::ccmath::floor(x.my_first()) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::floor(x.my_first()) }; if (fhi != x.my_first()) { @@ -1364,7 +1412,7 @@ constexpr auto eval_floor(cpp_double_fp_backend& result, cons } else { - const local_float_type flo = { cpp_df_qf_detail::ccmath::floor(x.my_second()) }; + const local_float_type flo = { cpp_df_qf_detail::ccmath::unsafe::floor(x.my_second()) }; result.rep() = local_backend_type::arithmetic::normalize(fhi, flo); } @@ -1438,7 +1486,7 @@ constexpr auto eval_sqrt(cpp_double_fp_backend& result, const // TBD: Do we need any overflow/underflow guards when multiplying // by the split or when multiplying (hx * tx) and/or (hx * hx)? - const local_float_type c { cpp_df_qf_detail::ccmath::sqrt(o.crep().first) }; + const local_float_type c { cpp_df_qf_detail::ccmath::unsafe::sqrt(o.crep().first) }; local_float_type p { cpp_df_qf_detail::split_maker::value * c }; @@ -1660,6 +1708,8 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const int fpc { eval_fpclassify(x) }; + const bool b_neg { x.isneg_unchecked() }; + if (fpc == FP_ZERO) { result = one; @@ -1668,7 +1718,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const { if (fpc == FP_INFINITE) { - result = (x.isneg_unchecked() ? double_float_type { 0.0F } : double_float_type::my_value_inf()); + result = (b_neg ? double_float_type { 0.0F } : double_float_type::my_value_inf()); } else if (fpc == FP_NAN) { @@ -1680,42 +1730,15 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. - const bool b_neg { x.isneg_unchecked() }; const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } @@ -1810,6 +1833,8 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const int fpc { eval_fpclassify(x) }; + const bool b_neg { x.isneg_unchecked() }; + if (fpc == FP_ZERO) { result = one; @@ -1818,7 +1843,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const { if (fpc == FP_INFINITE) { - result = (x.isneg_unchecked() ? double_float_type(0) : double_float_type::my_value_inf()); + result = (b_neg ? double_float_type(0) : double_float_type::my_value_inf()); } else if (fpc == FP_NAN) { @@ -1830,42 +1855,15 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. - const bool b_neg { x.isneg_unchecked() }; const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } @@ -1962,6 +1960,8 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const int fpc { eval_fpclassify(x) }; + const bool b_neg { x.isneg_unchecked() }; + if (fpc == FP_ZERO) { result = one; @@ -1970,7 +1970,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const { if (fpc == FP_INFINITE) { - result = (x.isneg_unchecked() ? double_float_type(0) : double_float_type::my_value_inf()); + result = (b_neg ? double_float_type(0) : double_float_type::my_value_inf()); } else if (fpc == FP_NAN) { @@ -1982,42 +1982,14 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. - const bool b_neg { x.isneg_unchecked() }; - const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } @@ -2150,8 +2122,8 @@ constexpr auto eval_log(cpp_double_fp_backend& result, const eval_frexp(x2, x, &n2); - // Get initial estimate using the (wrapped) standard math function log. - const double_float_type s(cpp_df_qf_detail::ccmath::log(x2.my_first())); + // Get initial estimate using the self-written, detail math function log. + const double_float_type s(cpp_df_qf_detail::ccmath::unsafe::log(x2.my_first())); double_float_type E { }; @@ -2307,7 +2279,7 @@ constexpr auto eval_convert_to(unsigned long long* result, const cpp_double_fp_b if (fpc != FP_NORMAL) { - *result = static_cast(backend.crep().first); + *result = static_cast(backend.crep().first); } else { @@ -2435,7 +2407,7 @@ constexpr auto eval_convert_to(boost::uint128_type* result, const cpp_double_fp_ using longer_type = typename ::std::conditional::type; - constexpr boost::int128_type my_max_val_u128 = static_cast(~static_cast(0)); + constexpr boost::uint128_type my_max_val_u128 = static_cast(~static_cast(0)); constexpr longer_type my_max_val(static_cast(my_max_val_u128)); diff --git a/test/math/test_bessel_j.cpp b/test/math/test_bessel_j.cpp index 7a57d988e..073e421c9 100644 --- a/test/math/test_bessel_j.cpp +++ b/test/math/test_bessel_j.cpp @@ -8,8 +8,10 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 -#include "setup.hpp" -#include "table_type.hpp" +#define TEST_CPP_DOUBLE_FLOAT + +#include "./setup.hpp" +#include "./table_type.hpp" #include #include "test_bessel_j.hpp" @@ -62,7 +64,7 @@ void expected_results() ".*", // platform ".*cpp_double_double.*", // test type(s) ".*(JN|j).*|.*Tricky.*", // test data group - ".*", 100000, 100000); // test function + ".*", 100000, 50000); // test function add_expected_result( ".*", // compiler ".*", // stdlib @@ -84,13 +86,6 @@ void expected_results() ".*cpp_bin_float.*", // test type(s) ".*(JN|j).*|.*Tricky.*", // test data group ".*", 500000, 200000); // test function - add_expected_result( - ".*", // compiler - ".*", // stdlib - ".*", // platform - ".*cpp_double_double.*", // test type(s) - ".*(JN|j).*|.*Tricky.*", // test data group - ".*", 24000, 10000); // test function add_expected_result( ".*", // compiler ".*", // stdlib diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 85b4e0f58..5d85f2070 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -13,8 +13,39 @@ #include "test_arithmetic.hpp" +void test_constexpr_ness() +{ + using boost::multiprecision::cpp_double_double; + + constexpr cpp_double_double one { 1 }; + + static_assert(static_cast(one) == 1, "Error: constexpr cpp_double_double construction failed"); + + BOOST_CHECK(static_cast(one) == 1); + + constexpr cpp_double_double dd_a { 1.23 }; + constexpr cpp_double_double dd_b { 4.56 }; + constexpr cpp_double_double dd_c { dd_a * dd_b }; + + constexpr cpp_double_double dd_s { sqrt(dd_a) }; + constexpr cpp_double_double sqrt_hundred { sqrt(cpp_double_double(100)) }; + constexpr cpp_double_double log_hundred { log(cpp_double_double(100)) }; + + static_assert(dd_c > 5, "Error in constexpr multiplication"); + static_assert(dd_s > 1, "Error in constexpr square root"); + static_assert(sqrt_hundred == 10, "Error in constexpr square root"); + static_assert(log_hundred > 4.605, "Error in constexpr logarithm"); + + BOOST_CHECK(dd_c > 5); + BOOST_CHECK(dd_s > 1); + BOOST_CHECK(sqrt_hundred == 10); + BOOST_CHECK(log_hundred > 4.605); +} + int main() { + ::test_constexpr_ness(); + using boost::multiprecision::cpp_double_float; using boost::multiprecision::cpp_double_double; using boost::multiprecision::cpp_double_long_double; @@ -22,10 +53,6 @@ int main() using boost::multiprecision::cpp_double_float128; #endif - constexpr cpp_double_double one { 1 }; - - static_assert(static_cast(one) == 1, "Error:constexpr-ness of cpp_double_double constructor failed"); - test(); test(); test(); From 2f737ffa6372582b3f9c9ccea9b2ee7b8b8764ad Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 25 Aug 2025 19:39:35 +0200 Subject: [PATCH 056/114] Patch std::is_same for old MSVC C++14 --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index 38f265628..0eea47a31 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -21,15 +21,15 @@ template constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept { #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) - BOOST_IF_CONSTEXPR (std::is_same_v) + BOOST_IF_CONSTEXPR (std::is_same::value) { return __builtin_fmaf(x, y, z); } - else BOOST_IF_CONSTEXPR (std::is_same_v) + else BOOST_IF_CONSTEXPR (std::is_same::value) { return __builtin_fma(x, y, z); } - else BOOST_IF_CONSTEXPR (std::is_same_v) + else BOOST_IF_CONSTEXPR (std::is_same::value) { return __builtin_fmal(x, y, z); } From d1982bfca9bf5fe44cb681fd9c86cc3290c82cfd Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 29 Aug 2025 14:07:10 +0200 Subject: [PATCH 057/114] Handle review comments --- .../multiprecision/detail/default_ops.hpp | 34 ++----------------- .../multiprecision/detail/functions/pow.hpp | 8 ++--- 2 files changed, 6 insertions(+), 36 deletions(-) diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index 6fd4b65eb..87ada6e4d 100644 --- a/include/boost/multiprecision/detail/default_ops.hpp +++ b/include/boost/multiprecision/detail/default_ops.hpp @@ -2619,13 +2619,6 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number& arg) { - const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; - - if (fpc_arg == FP_ZERO) - { - return arg; - } - detail::scoped_default_precision > precision_guard(arg); return boost::math::erf(arg, c99_error_policy()); } @@ -2634,14 +2627,6 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression::result_type; detail::scoped_default_precision precision_guard(arg); - - const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; - - if (fpc_arg == FP_ZERO) - { - return arg; - } - return erf(value_type(arg)); } template @@ -2693,27 +2678,12 @@ inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number& arg) { - using local_number_type = multiprecision::number; - - detail::scoped_default_precision precision_guard(arg); - - const int fpc_arg { (boost::multiprecision::fpclassify)(arg) }; - - if ((fpc_arg == FP_ZERO) && std::numeric_limits::has_infinity) + detail::scoped_default_precision > precision_guard(arg); + if ((arg == 0) && std::numeric_limits >::has_infinity) { errno = ERANGE; return 1 / arg; } - else if ((fpc_arg == FP_NAN) && std::numeric_limits::has_quiet_NaN) - { - return arg; - } - else if ((fpc_arg == FP_INFINITE) && std::numeric_limits::has_infinity && std::numeric_limits::has_quiet_NaN) - { - const bool is_neg { arg.compare(local_number_type(0)) < 0 }; - - return ((!is_neg) ? std::numeric_limits::infinity() : std::numeric_limits::quiet_NaN()); - } return boost::math::tgamma(arg, c99_error_policy()); } template diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index e79aacff1..9cf265fb1 100644 --- a/include/boost/multiprecision/detail/functions/pow.hpp +++ b/include/boost/multiprecision/detail/functions/pow.hpp @@ -509,15 +509,15 @@ inline void eval_pow(T& result, const T& x, const T& a) return; } - const int fpc_x { eval_fpclassify(x) }; - const int fpc_a { eval_fpclassify(a) }; - - if (fpc_a == FP_ZERO) + if (eval_is_zero(a)) { result = si_type(1); return; } + const int fpc_x { eval_fpclassify(x) }; + const int fpc_a { eval_fpclassify(a) }; + switch (fpc_x) { case FP_ZERO: From 61d99d0d93cf2f1da38cf12cfd74672ff4c8e63a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 29 Aug 2025 14:53:06 +0200 Subject: [PATCH 058/114] Repair minor defects in CI --- test/math/test_bessel_j.cpp | 6 ++---- test/test_various_edges_more.cpp | 4 ++-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/test/math/test_bessel_j.cpp b/test/math/test_bessel_j.cpp index 073e421c9..d5484832a 100644 --- a/test/math/test_bessel_j.cpp +++ b/test/math/test_bessel_j.cpp @@ -8,10 +8,8 @@ // "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations", // in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469 -#define TEST_CPP_DOUBLE_FLOAT - -#include "./setup.hpp" -#include "./table_type.hpp" +#include "setup.hpp" +#include "table_type.hpp" #include #include "test_bessel_j.hpp" diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 2e4c0b7ec..b8163cc3c 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -5,9 +5,9 @@ // Some parts of this test file have been taken from the Boost.Decimal project. -#define TEST_CPP_BIN_FLOAT -#define TEST_CPP_DEC_FLOAT +#if !defined(TEST_CPP_DOUBLE_FLOAT) #define TEST_CPP_DOUBLE_FLOAT +#endif #include #include From ec857ee9324979057927f4049d69e692cdf88113 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 29 Aug 2025 15:46:28 +0200 Subject: [PATCH 059/114] Exclude known constexpr-eval lines from cover --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp | 4 +++- .../multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 4 +++- .../cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp | 4 ++++ .../cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp | 4 +++- .../multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 4 +++- .../multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp | 4 +++- 6 files changed, 19 insertions(+), 5 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp index 84d5d66c0..42b36be21 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp @@ -19,6 +19,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr auto floor_pos_impl(Real arg) noexcept -> Real { @@ -93,6 +94,7 @@ constexpr auto floor_impl(Real arg) noexcept -> Real return floor_neg_impl(arg); } } +// LCOV_EXCL_STOP } // namespace detail @@ -101,7 +103,7 @@ constexpr auto floor(Real x) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(x)) { - return detail::floor_impl(x); + return detail::floor_impl(x); // LCOV_EXCL_LINE } else { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index 0eea47a31..909b8607a 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -17,6 +17,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept { @@ -38,6 +39,7 @@ constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept // If we can't use compiler intrinsics hope that -fma flag optimizes this call to fma instruction return (x * y) + z; } +// LCOV_EXCL_STOP } // namespace detail @@ -46,7 +48,7 @@ constexpr auto fma(Real x, Real y, Real z) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(x)) { - return detail::fma_impl(x, y, z); + return detail::fma_impl(x, y, z); // LCOV_EXCL_LINE } else { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp index 20ac79cca..6b9aecdf4 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp @@ -17,6 +17,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr auto frexp_impl(Real arg, int* expptr) noexcept -> Real { @@ -58,6 +59,7 @@ constexpr auto frexp_impl(Real arg, int* expptr) noexcept -> Real return ((!negative_arg) ? f : -f); } +// LCOV_EXCL_STOP } // namespace detail @@ -66,6 +68,7 @@ constexpr auto frexp(Real arg, int* expptr) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(arg)) { + // LCOV_EXCL_START if (arg == static_cast(0)) { *expptr = 0; @@ -76,6 +79,7 @@ constexpr auto frexp(Real arg, int* expptr) -> Real { return detail::frexp_impl(arg, expptr); } + // LCOV_EXCL_STOP } else { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index 0f45822ee..fae5507fe 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -17,6 +17,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real { @@ -48,6 +49,7 @@ constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real return arg; } +// LCOV_EXCL_STOP } // Namespace detail @@ -56,7 +58,7 @@ constexpr auto ldexp(Real arg, int expval) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(x)) { - return detail::ldexp_impl(arg, expval); + return detail::ldexp_impl(arg, expval); // LCOV_EXCL_LINE } else { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 3846fe4a2..525e75d40 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -30,6 +30,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr auto exp_impl(Real x) noexcept -> Real { @@ -148,6 +149,7 @@ constexpr auto log_impl(Real x) noexcept -> Real return s; } +// LCOV_EXCL_STOP } // namespace detail @@ -156,7 +158,7 @@ constexpr auto log(Real x) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(x)) { - return detail::log_impl(x); + return detail::log_impl(x); // LCOV_EXCL_LINE } else { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 29d06eb2c..92d01d62d 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -17,6 +17,7 @@ namespace unsafe { namespace detail { +// LCOV_EXCL_START template constexpr auto sqrt_impl_2(Real x, Real s, Real s2) noexcept -> Real { @@ -34,6 +35,7 @@ constexpr auto sqrt_impl(Real x) noexcept -> Real { return sqrt_impl_1(x, x > 1 ? x : Real(1)); } +// LCOV_EXCL_STOP } // namespace detail @@ -42,7 +44,7 @@ constexpr auto sqrt(Real x) -> Real { if (BOOST_MP_IS_CONST_EVALUATED(x)) { - return detail::sqrt_impl(x); + return detail::sqrt_impl(x); // LCOV_EXCL_LINE } else { From 79e86d964156bf347ad3f1afc065273d4908dcfc Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 29 Aug 2025 21:21:54 +0200 Subject: [PATCH 060/114] Try repair syntax for old compilers --- .../boost/multiprecision/cpp_double_fp.hpp | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index a92cff558..a0d6b903f 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -963,7 +963,7 @@ class cpp_double_fp_backend ) }; - constexpr cpp_double_fp_backend my_value_max_constexpr { arithmetic::two_hilo_sum(hi_part, lo_part) }; + constexpr cpp_double_fp_backend my_value_max_constexpr(arithmetic::two_hilo_sum(hi_part, lo_part)); static_assert ( @@ -991,7 +991,7 @@ class cpp_double_fp_backend static_assert ( - eval_gt(my_value_min_constexpr, cpp_double_fp_backend { (cpp_df_qf_detail::ccmath::numeric_limits::min)() }), + eval_gt(my_value_min_constexpr, cpp_double_fp_backend((cpp_df_qf_detail::ccmath::numeric_limits::min)())), "Error: minimum value is too small and must exceed the min of its constituent type" ); @@ -1008,7 +1008,7 @@ class cpp_double_fp_backend static_assert ( - eval_lt(cpp_double_fp_backend { 1 } - my_value_eps_constexpr, cpp_double_fp_backend { 1 }), + eval_lt(cpp_double_fp_backend(1) - my_value_eps_constexpr, cpp_double_fp_backend(1)), "Error: epsilon value is too small and must be large enough to differentiate (1 - epsilon) from 1" ); @@ -1034,16 +1034,16 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use an order-2 // approximation for the second logarithm. - constexpr float_type my_a { my_value_max().my_first() }; - constexpr float_type my_b { my_value_max().my_second() }; + constexpr float_type my_a(my_value_max().my_first()); + constexpr float_type my_b(my_value_max().my_second()); constexpr float_type dx { my_b / my_a }; constexpr cpp_double_fp_backend my_value_logmax_constexpr { - cpp_double_fp_backend { cpp_df_qf_detail::ccmath::unsafe::log(my_a) } - + cpp_double_fp_backend { dx * (static_cast(1.0F) - dx / static_cast(2.0F)) } + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) }; return my_value_logmax_constexpr; @@ -1058,16 +1058,16 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use an order-2 // approximation for the second logarithm. - constexpr float_type my_a { my_value_min().my_first() }; - constexpr float_type my_b { my_value_min().my_second() }; + constexpr float_type my_a(my_value_min().my_first()); + constexpr float_type my_b(my_value_min().my_second()); constexpr float_type dx { my_b / my_a }; constexpr cpp_double_fp_backend my_value_logmin_constexpr { - cpp_double_fp_backend { cpp_df_qf_detail::ccmath::unsafe::log(my_a) } - + cpp_double_fp_backend { dx * (static_cast(1.0F) - dx / static_cast(2.0F)) } + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) }; return my_value_logmin_constexpr; From c206385b2943870310318a20ab3e90739a60281b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Fri, 29 Aug 2025 22:37:41 +0200 Subject: [PATCH 061/114] Retry old compiler constexpr-ness --- .../boost/multiprecision/cpp_double_fp.hpp | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index a0d6b903f..0cf76a55c 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1034,17 +1034,19 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use an order-2 // approximation for the second logarithm. - constexpr float_type my_a(my_value_max().my_first()); - constexpr float_type my_b(my_value_max().my_second()); + constexpr cpp_double_fp_backend local_value_max = my_value_max(); + + constexpr float_type my_a(local_value_max.data.first); + constexpr float_type my_b(local_value_max.data.second); constexpr float_type dx { my_b / my_a }; constexpr cpp_double_fp_backend my_value_logmax_constexpr - { + ( cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) - }; + ); return my_value_logmax_constexpr; } @@ -1058,17 +1060,19 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use an order-2 // approximation for the second logarithm. - constexpr float_type my_a(my_value_min().my_first()); - constexpr float_type my_b(my_value_min().my_second()); + constexpr cpp_double_fp_backend local_value_min = my_value_min(); + + constexpr float_type my_a(local_value_min.data.first); + constexpr float_type my_b(local_value_min.data.second); constexpr float_type dx { my_b / my_a }; constexpr cpp_double_fp_backend my_value_logmin_constexpr - { + ( cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) - }; + ); return my_value_logmin_constexpr; } From 91e9ea721a931705a7ac9abf59bd07e8eb328965 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 09:24:19 +0200 Subject: [PATCH 062/114] Simplify constexpr-ness and correct a typo --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 2 +- .../cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp | 2 +- include/boost/multiprecision/cpp_double_fp.hpp | 6 ++++-- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index 909b8607a..880edc891 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -46,7 +46,7 @@ constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept template constexpr auto fma(Real x, Real y, Real z) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(x)) + if (BOOST_MP_IS_CONST_EVALUATED(x) && BOOST_MP_IS_CONST_EVALUATED(y) && BOOST_MP_IS_CONST_EVALUATED(z)) { return detail::fma_impl(x, y, z); // LCOV_EXCL_LINE } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index fae5507fe..1dab6b3f1 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -56,7 +56,7 @@ constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real template constexpr auto ldexp(Real arg, int expval) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(x)) + if (BOOST_MP_IS_CONST_EVALUATED(arg)) { return detail::ldexp_impl(arg, expval); // LCOV_EXCL_LINE } diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 0cf76a55c..56b7a7ae1 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -979,8 +979,8 @@ class cpp_double_fp_backend // Use the non-normalized minimum value, where the lower value // is "shifted" left in the sense of floating-point ldexp. - constexpr cpp_double_fp_backend - my_value_min_constexpr + constexpr float_type + hi_part { cpp_df_qf_detail::ccmath::unsafe::ldexp ( @@ -989,6 +989,8 @@ class cpp_double_fp_backend ) }; + constexpr cpp_double_fp_backend my_value_min_constexpr { hi_part }; + static_assert ( eval_gt(my_value_min_constexpr, cpp_double_fp_backend((cpp_df_qf_detail::ccmath::numeric_limits::min)())), From 62222f88b15290ccdc242fd607615540c8081c6c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 13:04:16 +0200 Subject: [PATCH 063/114] Patch constexpr-ness for old GCC --- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 6 ++++++ include/boost/multiprecision/cpp_double_fp.hpp | 18 +++++++++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index 1dab6b3f1..d0207ce7a 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -68,6 +68,12 @@ constexpr auto ldexp(Real arg, int expval) -> Real } } +template +constexpr auto ldexp_constexpr(Real arg, int expval) -> Real +{ + return detail::ldexp_impl(arg, expval); +} + } // namespace unsafe } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 56b7a7ae1..cd1ea7d9b 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -956,7 +956,11 @@ class cpp_double_fp_backend constexpr float_type lo_part { + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr + #else cpp_df_qf_detail::ccmath::unsafe::ldexp + #endif ( (cpp_df_qf_detail::ccmath::numeric_limits::max)(), -cpp_df_qf_detail::ccmath::numeric_limits::digits @@ -982,7 +986,11 @@ class cpp_double_fp_backend constexpr float_type hi_part { + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr + #else cpp_df_qf_detail::ccmath::unsafe::ldexp + #endif ( (cpp_df_qf_detail::ccmath::numeric_limits::min)(), cpp_df_qf_detail::ccmath::numeric_limits::digits @@ -1005,7 +1013,15 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_eps_constexpr { - cpp_df_qf_detail::ccmath::unsafe::ldexp(float_type { 1 }, int { 3 - my_digits }) + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr + #else + cpp_df_qf_detail::ccmath::unsafe::ldexp + #endif + ( + float_type { 1 }, + int { 3 - my_digits } + ) }; static_assert From f351909ee8200b92ecd0acc284933e296003addf Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 14:01:57 +0200 Subject: [PATCH 064/114] More patch constexpr-ness old GCC --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 6 ++++++ .../cpp_df_qf_detail_ccmath_sqrt.hpp | 6 ++++++ .../boost/multiprecision/cpp_double_fp.hpp | 20 ++++++++++++++++++- 3 files changed, 31 insertions(+), 1 deletion(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 525e75d40..7b5467733 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -168,6 +168,12 @@ constexpr auto log(Real x) -> Real } } +template +constexpr auto log_constexpr(Real x) -> Real +{ + return detail::log_impl(x); +} + } // namespace unsafe } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 92d01d62d..954e4199f 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -54,6 +54,12 @@ constexpr auto sqrt(Real x) -> Real } } +template +constexpr auto sqrt_constexpr(Real x) -> Real +{ + return detail::sqrt_impl(x); +} + } // namespace unsafe } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index cd1ea7d9b..c08a84322 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -949,7 +949,17 @@ class cpp_double_fp_backend (cpp_df_qf_detail::ccmath::numeric_limits::max)() * ( static_cast(1.0F) - - static_cast(1.5F) * cpp_df_qf_detail::ccmath::unsafe::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + - ( + static_cast(1.5F) + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + * cpp_df_qf_detail::ccmath::unsafe::sqrt_constexpr + #else + * cpp_df_qf_detail::ccmath::unsafe::sqrt + #endif + ( + cpp_df_qf_detail::ccmath::numeric_limits::epsilon() + ) + ) ) }; @@ -1062,7 +1072,11 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_logmax_constexpr ( + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(my_a)) + #else cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + #endif + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) ); @@ -1088,7 +1102,11 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_logmin_constexpr ( + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(my_a)) + #else cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) + #endif + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) ); From 324cc5f12f90a81a85446f6f95c24c84cbca3b5f Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 15:39:30 +0200 Subject: [PATCH 065/114] Simplify constexpr-ness and deactivate a test --- .../boost/multiprecision/cpp_double_fp.hpp | 74 ++++++++++++------- test/test_various_edges.cpp | 2 + 2 files changed, 48 insertions(+), 28 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index c08a84322..e23ab7660 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1059,25 +1059,37 @@ class cpp_double_fp_backend // which we refactor as first * (1 + second / first). // We approximate log(first * (1 + second / first)) with - // log(first) + log(1 + second/first), and use an order-2 - // approximation for the second logarithm. + // log(first) + log(1 + second/first), and use a value of + // zero for the second logarithm. - constexpr cpp_double_fp_backend local_value_max = my_value_max(); - - constexpr float_type my_a(local_value_max.data.first); - constexpr float_type my_b(local_value_max.data.second); - - constexpr float_type dx { my_b / my_a }; + constexpr float_type + first + { + (cpp_df_qf_detail::ccmath::numeric_limits::max)() + * ( + static_cast(1.0F) + - ( + static_cast(1.5F) + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + * cpp_df_qf_detail::ccmath::unsafe::sqrt_constexpr + #else + * cpp_df_qf_detail::ccmath::unsafe::sqrt + #endif + ( + cpp_df_qf_detail::ccmath::numeric_limits::epsilon() + ) + ) + ) + }; constexpr cpp_double_fp_backend my_value_logmax_constexpr ( - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(my_a)) - #else - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) - #endif - + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(first)) + #else + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) + #endif ); return my_value_logmax_constexpr; @@ -1089,25 +1101,31 @@ class cpp_double_fp_backend // which we refactor as first * (1 + second / first). // We approximate log(first * (1 + second / first)) with - // log(first) + log(1 + second/first), and use an order-2 - // approximation for the second logarithm. - - constexpr cpp_double_fp_backend local_value_min = my_value_min(); - - constexpr float_type my_a(local_value_min.data.first); - constexpr float_type my_b(local_value_min.data.second); + // log(first) + log(1 + second/first), and use a value of + // zero for the second logarithm. - constexpr float_type dx { my_b / my_a }; + constexpr float_type + first + { + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr + #else + cpp_df_qf_detail::ccmath::unsafe::ldexp + #endif + ( + (cpp_df_qf_detail::ccmath::numeric_limits::min)(), + cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + }; constexpr cpp_double_fp_backend my_value_logmin_constexpr ( - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(my_a)) - #else - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(my_a)) - #endif - + cpp_double_fp_backend(dx * (static_cast(1.0F) - dx / static_cast(2.0F))) + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(first)) + #else + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) + #endif ); return my_value_logmin_constexpr; diff --git a/test/test_various_edges.cpp b/test/test_various_edges.cpp index 260b5c624..145ecaa0b 100644 --- a/test/test_various_edges.cpp +++ b/test/test_various_edges.cpp @@ -1427,6 +1427,7 @@ namespace local BOOST_IF_CONSTEXPR(is_24_digit_float && is_cpp_double_float) { + #if 0 for(auto index = 0U; index < 8U; ++index) { using std::ldexp; @@ -1502,6 +1503,7 @@ namespace local result_is_ok = (result_val_uinf_is_ok && result_is_ok); result_is_ok = (result_val_uzer_is_ok && result_is_ok); } + #endif } else { From a26871b55af463fc01ef3e9e8a2e7c848c216b84 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 16:14:32 +0200 Subject: [PATCH 066/114] Remove some constexpr reqs for old GCC --- .../boost/multiprecision/cpp_double_fp.hpp | 70 ++++++++++++++++--- test/test_arithmetic_df.cpp | 10 ++- 2 files changed, 68 insertions(+), 12 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index e23ab7660..b78e79216 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1053,7 +1053,47 @@ class cpp_double_fp_backend return cpp_double_fp_backend(static_cast(HUGE_VAL), float_type { 0.0F }); // conversion from double infinity OK } + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + static auto my_value_logmax() noexcept -> const cpp_double_fp_backend& + #else static constexpr auto my_value_logmax() noexcept -> cpp_double_fp_backend + #endif + { + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + static const cpp_double_fp_backend my_value_logmax_constexpr = my_value_logmax_maker(); + #else + constexpr cpp_double_fp_backend my_value_logmax_constexpr = my_value_logmax_maker(); + #endif + + return my_value_logmax_constexpr; + } + + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + static auto my_value_logmin() noexcept -> const cpp_double_fp_backend& + #else + static constexpr auto my_value_logmin() noexcept -> cpp_double_fp_backend + #endif + { + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + static const cpp_double_fp_backend my_value_logmin_constexpr = my_value_logmin_maker(); + #else + constexpr cpp_double_fp_backend my_value_logmin_constexpr = my_value_logmin_maker(); + #endif + + return my_value_logmin_constexpr; + } + + private: + rep_type data; + + using cpp_bin_float_read_write_backend_type = boost::multiprecision::backends::cpp_bin_float(my_digits), digit_base_2, void, int, cpp_df_qf_detail::ccmath::numeric_limits::min_exponent, cpp_df_qf_detail::ccmath::numeric_limits::max_exponent>; + using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; + + using cpp_bin_float_read_write_type = boost::multiprecision::number; + + auto rd_string(const char* pstr) -> bool; + + static constexpr auto my_value_logmax_maker() noexcept -> cpp_double_fp_backend { // Here, we note that max is composed of (first + second), // which we refactor as first * (1 + second / first). @@ -1092,10 +1132,19 @@ class cpp_double_fp_backend #endif ); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else + static_assert + ( + eval_gt(my_value_logmax_constexpr, cpp_double_fp_backend(1)), + "Error: logmax value is definitely incorrect" + ); + #endif + return my_value_logmax_constexpr; } - static constexpr auto my_value_logmin() noexcept -> cpp_double_fp_backend + static constexpr auto my_value_logmin_maker() noexcept -> cpp_double_fp_backend { // Here, we note that min is composed of (first + second), // which we refactor as first * (1 + second / first). @@ -1128,19 +1177,18 @@ class cpp_double_fp_backend #endif ); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else + static_assert + ( + eval_lt(my_value_logmin_constexpr, cpp_double_fp_backend(-1)), + "Error: logmin value is definitely incorrect" + ); + #endif + return my_value_logmin_constexpr; } - private: - rep_type data; - - using cpp_bin_float_read_write_backend_type = boost::multiprecision::backends::cpp_bin_float(my_digits), digit_base_2, void, int, cpp_df_qf_detail::ccmath::numeric_limits::min_exponent, cpp_df_qf_detail::ccmath::numeric_limits::max_exponent>; - using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; - - using cpp_bin_float_read_write_type = boost::multiprecision::number; - - auto rd_string(const char* pstr) -> bool; - constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void { // The multiplication algorithm has been taken from Victor Shoup, diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 5d85f2070..0f21169af 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -29,12 +29,20 @@ void test_constexpr_ness() constexpr cpp_double_double dd_s { sqrt(dd_a) }; constexpr cpp_double_double sqrt_hundred { sqrt(cpp_double_double(100)) }; - constexpr cpp_double_double log_hundred { log(cpp_double_double(100)) }; + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + const + #else + constexpr + #endif + cpp_double_double log_hundred { log(cpp_double_double(100)) }; static_assert(dd_c > 5, "Error in constexpr multiplication"); static_assert(dd_s > 1, "Error in constexpr square root"); static_assert(sqrt_hundred == 10, "Error in constexpr square root"); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else static_assert(log_hundred > 4.605, "Error in constexpr logarithm"); + #endif BOOST_CHECK(dd_c > 5); BOOST_CHECK(dd_s > 1); From bb4911ceb3de4fab69aac2a022d996b35b8a0832 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 20:37:52 +0200 Subject: [PATCH 067/114] Readjust old compiler constexpr-ness --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 8 +++ .../boost/multiprecision/cpp_double_fp.hpp | 72 +++++++++++++------ 2 files changed, 58 insertions(+), 22 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 7b5467733..fd752c52b 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -174,6 +174,14 @@ constexpr auto log_constexpr(Real x) -> Real return detail::log_impl(x); } +template +constexpr auto log_non_constexpr(Real x) -> Real +{ + using std::log; + + return log(x); +} + } // namespace unsafe } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index b78e79216..278d52870 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1060,12 +1060,12 @@ class cpp_double_fp_backend #endif { #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static const cpp_double_fp_backend my_value_logmax_constexpr = my_value_logmax_maker(); + static const cpp_double_fp_backend my_value_logmax_non_constexpr = my_value_logmax_maker(); + + return my_value_logmax_non_constexpr; #else - constexpr cpp_double_fp_backend my_value_logmax_constexpr = my_value_logmax_maker(); + return my_value_logmax_maker(); #endif - - return my_value_logmax_constexpr; } #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) @@ -1075,12 +1075,12 @@ class cpp_double_fp_backend #endif { #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static const cpp_double_fp_backend my_value_logmin_constexpr = my_value_logmin_maker(); + static const cpp_double_fp_backend my_value_logmin_non_constexpr = my_value_logmin_maker(); + + return my_value_logmin_non_constexpr; #else - constexpr cpp_double_fp_backend my_value_logmin_constexpr = my_value_logmin_maker(); + return my_value_logmin_maker(); #endif - - return my_value_logmin_constexpr; } private: @@ -1093,7 +1093,11 @@ class cpp_double_fp_backend auto rd_string(const char* pstr) -> bool; - static constexpr auto my_value_logmax_maker() noexcept -> cpp_double_fp_backend + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else + constexpr + #endif + static auto my_value_logmax_maker() noexcept -> cpp_double_fp_backend { // Here, we note that max is composed of (first + second), // which we refactor as first * (1 + second / first). @@ -1102,7 +1106,12 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use a value of // zero for the second logarithm. - constexpr float_type + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + const + #else + constexpr + #endif + float_type first { (cpp_df_qf_detail::ccmath::numeric_limits::max)() @@ -1122,11 +1131,16 @@ class cpp_double_fp_backend ) }; - constexpr cpp_double_fp_backend - my_value_logmax_constexpr + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + const + #else + constexpr + #endif + cpp_double_fp_backend + my_value_logmax_constexpr_or_const ( #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(first)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_non_constexpr(first)) #else cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) #endif @@ -1136,15 +1150,19 @@ class cpp_double_fp_backend #else static_assert ( - eval_gt(my_value_logmax_constexpr, cpp_double_fp_backend(1)), + eval_gt(my_value_logmax_constexpr_or_const, cpp_double_fp_backend(1)), "Error: logmax value is definitely incorrect" ); #endif - return my_value_logmax_constexpr; + return my_value_logmax_constexpr_or_const; } - static constexpr auto my_value_logmin_maker() noexcept -> cpp_double_fp_backend + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else + constexpr + #endif + static auto my_value_logmin_maker() noexcept -> cpp_double_fp_backend { // Here, we note that min is composed of (first + second), // which we refactor as first * (1 + second / first). @@ -1153,7 +1171,12 @@ class cpp_double_fp_backend // log(first) + log(1 + second/first), and use a value of // zero for the second logarithm. - constexpr float_type + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + const + #else + constexpr + #endif + float_type first { #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) @@ -1167,11 +1190,16 @@ class cpp_double_fp_backend ) }; - constexpr cpp_double_fp_backend - my_value_logmin_constexpr + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + const + #else + constexpr + #endif + cpp_double_fp_backend + my_value_logmin_constexpr_or_const ( #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_constexpr(first)) + cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_non_constexpr(first)) #else cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) #endif @@ -1181,12 +1209,12 @@ class cpp_double_fp_backend #else static_assert ( - eval_lt(my_value_logmin_constexpr, cpp_double_fp_backend(-1)), + eval_lt(my_value_logmin_constexpr_or_const, cpp_double_fp_backend(-1)), "Error: logmin value is definitely incorrect" ); #endif - return my_value_logmin_constexpr; + return my_value_logmin_constexpr_or_const; } constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void From ac1b9545e7775bfb7918f5558f74567a897bbe93 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 30 Aug 2025 21:29:53 +0200 Subject: [PATCH 068/114] Syntax and exclude test very old compiler --- include/boost/multiprecision/cpp_double_fp.hpp | 15 +++++++++------ test/test_round.cpp | 3 +++ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 278d52870..ac3f4d944 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1029,8 +1029,7 @@ class cpp_double_fp_backend cpp_df_qf_detail::ccmath::unsafe::ldexp #endif ( - float_type { 1 }, - int { 3 - my_digits } + float_type { 1 }, int { 3 - my_digits } ) }; @@ -2772,14 +2771,18 @@ struct precision; + static constexpr auto use_full_precision() noexcept -> bool + { + return ((digits2_type::value <= precision_type::value) || (precision_type::value <= 0)); + } + public: using precision_type = typename Policy::precision_type; using type = - typename std::conditional< - ((digits2_type::value <= precision_type::value) || (precision_type::value <= 0)), - digits2_type, // This is the default case: Use full precision for RealType. - precision_type>::type; // Here we find (and use) user-customized precision. + typename std::conditional::type; // Here we find (and use) user-customized precision. }; } } } // namespace boost::math::policies diff --git a/test/test_round.cpp b/test/test_round.cpp index c57bd4d8a..41dc12a8d 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -510,12 +510,15 @@ int main() test(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT +#if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) +#else test(); test(); test(); #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif +#endif #endif return boost::report_errors(); From 5b533226741a32a3a41e641e38554a5cd50a88a7 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 31 Aug 2025 10:12:22 +0200 Subject: [PATCH 069/114] Revert constexpr-ness efforts --- .../cpp_df_qf_detail_ccmath_fabs.hpp | 2 +- .../cpp_df_qf_detail_ccmath_floor.hpp | 95 +----- .../cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 56 ++- .../cpp_df_qf_detail_ccmath_fpclassify.hpp | 11 +- .../cpp_df_qf_detail_ccmath_frexp.hpp | 75 +--- .../cpp_df_qf_detail_ccmath_isnan.hpp | 2 +- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 63 ++-- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 164 +-------- .../cpp_df_qf_detail_ccmath_sqrt.hpp | 40 +-- .../cpp_df_qf/cpp_df_qf_detail_constants.hpp | 30 +- .../boost/multiprecision/cpp_double_fp.hpp | 319 ++++++------------ test/test_arithmetic_df.cpp | 43 +-- test/test_round.cpp | 3 - test/test_various_edges.cpp | 41 ++- 14 files changed, 253 insertions(+), 691 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp index f71ef3501..cfd3b5260 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp @@ -14,7 +14,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto fabs(Real x) noexcept -> Real +constexpr auto fabs(Real x) -> Real { return (cpp_df_qf_detail::ccmath::isnan(x)) ? cpp_df_qf_detail::ccmath::numeric_limits::quiet_NaN() : (x == static_cast(-0)) ? static_cast(0) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp index 42b36be21..4df2f46a3 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp @@ -8,113 +8,30 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP -#include - #include #include namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace unsafe { - namespace detail { -// LCOV_EXCL_START -template -constexpr auto floor_pos_impl(Real arg) noexcept -> Real +template +constexpr auto floor_impl(T x) -> T { - constexpr auto - max_comp_val - { - Real(1) / ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::epsilon() - }; - - if (arg >= max_comp_val) - { - return arg; - } - - Real result { 1 }; - - if(result <= arg) - { - while(result < arg) - { - result *= 2; - } + // Default to the regular floor function. + using std::floor; - while(result > arg) - { - --result; - } - - return result; - } - else - { - return Real(0); - } + return floor(x); } -template -constexpr auto floor_neg_impl(Real arg) noexcept -> Real -{ - Real result { -1 }; - - if(result > arg) - { - while(result > arg) - { - result *= 2; - } - - while(result < arg) - { - ++result; - } - - if(result != arg) - { - --result; - } - } - - return result; -} - -template -constexpr auto floor_impl(Real arg) noexcept -> Real -{ - if(arg > 0) - { - return floor_pos_impl(arg); - } - else - { - return floor_neg_impl(arg); - } -} -// LCOV_EXCL_STOP - } // namespace detail template constexpr auto floor(Real x) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(x)) - { - return detail::floor_impl(x); // LCOV_EXCL_LINE - } - else - { - using std::floor; - - return floor(x); - } + return cpp_df_qf_detail::ccmath::detail::floor_impl(x); } -} // namespace unsafe - } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index 880edc891..f7117c8c2 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -17,45 +17,41 @@ namespace unsafe { namespace detail { -// LCOV_EXCL_START -template -constexpr Real fma_impl(const Real x, const Real y, const Real z) noexcept +template +constexpr auto fma_impl(T x, T y, T z) noexcept -> T { - #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) - BOOST_IF_CONSTEXPR (std::is_same::value) - { - return __builtin_fmaf(x, y, z); - } - else BOOST_IF_CONSTEXPR (std::is_same::value) - { - return __builtin_fma(x, y, z); - } - else BOOST_IF_CONSTEXPR (std::is_same::value) - { - return __builtin_fmal(x, y, z); - } - #endif + // Default to the written-out operations ... + // ... and hope the compiler chooses FMA if available). - // If we can't use compiler intrinsics hope that -fma flag optimizes this call to fma instruction return (x * y) + z; } -// LCOV_EXCL_STOP + +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) +template <> +constexpr auto fma_impl(float x, float y, float z) noexcept -> float +{ + return __builtin_fmaf(x, y, z); +} + +template <> +constexpr auto fma_impl(double x, double y, double z) noexcept -> double +{ + return __builtin_fma(x, y, z); +} + +template <> +constexpr auto fma_impl(long double x, long double y, long double z) noexcept -> long double +{ + return __builtin_fmal(x, y, z); +} +#endif } // namespace detail template -constexpr auto fma(Real x, Real y, Real z) -> Real +constexpr auto fma(Real x, Real y, Real z) noexcept -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(x) && BOOST_MP_IS_CONST_EVALUATED(y) && BOOST_MP_IS_CONST_EVALUATED(z)) - { - return detail::fma_impl(x, y, z); // LCOV_EXCL_LINE - } - else - { - using std::fma; - - return fma(x, y, z); - } + return detail::fma_impl(x, y, z); } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp index d378094d5..7824e99ad 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp @@ -11,14 +11,13 @@ #include #include #include -#include #include namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -template -constexpr auto fpclassify(Real x) noexcept -> int +template +constexpr auto fpclassify(T x) -> int { if ((::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::isnan)(x)) { @@ -30,13 +29,13 @@ constexpr auto fpclassify(Real x) noexcept -> int } else { - const Real fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; + const T fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; - if (fabs_x == Real(0)) + if (fabs_x == T(0)) { return FP_ZERO; } - else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) + else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) { return FP_SUBNORMAL; } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp index 6b9aecdf4..2ca53f32c 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp @@ -13,85 +13,26 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace unsafe { - -namespace detail { - -// LCOV_EXCL_START -template -constexpr auto frexp_impl(Real arg, int* expptr) noexcept -> Real +namespace detail { - const bool negative_arg { (arg < static_cast(0)) }; - - Real f { negative_arg ? -arg : arg }; - - int e2 { }; - - constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; - - while (f >= two_pow_16_plus) - { - f = f / two_pow_16_plus; - e2 += 16; - } - - constexpr Real two_pow_16_minus { static_cast(0.0000152587890625L) }; - while (f <= two_pow_16_minus) - { - f = f * two_pow_16_plus; - e2 -= 16; - } - - while(f >= static_cast(INT8_C(1))) - { - f = f / static_cast(INT8_C(2)); - ++e2; - } - - while(f < static_cast(0.5L)) - { - f = f * static_cast(INT8_C(2)); - --e2; - } - - *expptr = e2; +template +constexpr auto frexp_impl(T arg, int* expptr) -> T +{ + // Default to the regular frexp function. + using std::frexp; - return ((!negative_arg) ? f : -f); + return frexp(arg, expptr); } -// LCOV_EXCL_STOP } // namespace detail template constexpr auto frexp(Real arg, int* expptr) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(arg)) - { - // LCOV_EXCL_START - if (arg == static_cast(0)) - { - *expptr = 0; - - return arg; - } - else - { - return detail::frexp_impl(arg, expptr); - } - // LCOV_EXCL_STOP - } - else - { - // Default to the regular frexp function. - using std::frexp; - - return frexp(arg, expptr); - } + return detail::frexp_impl(arg, expptr); } -} // namespace unsafe - } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FREXP_2023_01_07_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp index 4e45ff60f..468a97b97 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp @@ -11,7 +11,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto isnan(FloatingPointType x) noexcept -> bool +constexpr auto isnan(FloatingPointType x) -> bool { return (x != x); } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index d0207ce7a..da2510969 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -13,65 +13,42 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace unsafe { - namespace detail { -// LCOV_EXCL_START -template -constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real +template +constexpr auto ldexp_impl(T arg, int expval) -> T { - constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; - - while(expval > 16) - { - arg *= two_pow_16_plus; - expval -= 16; - } - - while(expval < -16) - { - arg /= two_pow_16_plus; - expval += 16; - } - - while(expval > 0) - { - arg *= 2; - --expval; - } - - while(expval < 0) - { - arg /= 2; - ++expval; - } + // Default to the regular ldexp function. + using std::ldexp; - return arg; + return ldexp(arg, expval); } -// LCOV_EXCL_STOP } // Namespace detail template constexpr auto ldexp(Real arg, int expval) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(arg)) + return detail::ldexp_impl(arg, expval); +} + +namespace unsafe { + +template +constexpr auto ldexp(Real arg, int exp) noexcept -> Real +{ + while(exp > 0) { - return detail::ldexp_impl(arg, expval); // LCOV_EXCL_LINE + arg *= 2; + --exp; } - else + while(exp < 0) { - using std::ldexp; - - return ldexp(arg, expval); + arg /= 2; + ++exp; } -} -template -constexpr auto ldexp_constexpr(Real arg, int expval) -> Real -{ - return detail::ldexp_impl(arg, expval); + return arg; } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index fd752c52b..64cd301ed 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -8,182 +8,30 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP -#include -#include - #include #include -#if (defined(__GNUC__) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) -// -// This is the only way we can avoid -// warning: non-standard suffix on floating constant [-Wpedantic] -// when building with -Wall -pedantic. Neither __extension__ -// nor #pragma diagnostic ignored work :( -// -#pragma GCC system_header -#endif - namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace unsafe { - namespace detail { -// LCOV_EXCL_START -template -constexpr auto exp_impl(Real x) noexcept -> Real -{ - constexpr int - my_digits_10 - { - ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits10 - }; - - constexpr int - loop_count - { - my_digits_10 < 8 ? 7 - : my_digits_10 < 16 ? 15 - : my_digits_10 < 20 ? 19 - : 33 - }; - - // Scale the argument with a single factor of 2. - // Then square the result upon return. - x /= 2; - - // Perform a simple Taylor series of the exponent function. - Real term { x }; - Real sum { Real { 1 } + term }; - - for (int loop_index { INT8_C(2) }; loop_index < loop_count; ++loop_index) - { - term *= x; - term /= static_cast(loop_index); - sum += term; - } - - // Scale the result. - return sum * sum; -} - -template -constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54), Real>::type -{ - // PadeApproximant[Log[x], {x, 1, {8, 8}}] - // FullSimplify[%] - - const Real - top - { - ((static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(761.0L) + x * (static_cast(28544.0L) + x * (static_cast(209305.0L) + x * (static_cast(423680.0L) + x * (static_cast(209305.0L) + x * (static_cast(28544.0L) + static_cast(761.0L) * x))))))) - }; - - const Real - bot - { - (static_cast(140.0L) * (static_cast(1.0L) + x * (static_cast(64.0L) + x * (static_cast(784.0L) + x * (static_cast(3136.0L) + x * (static_cast(4900.0L) + x * (static_cast(3136.0L) + x * (static_cast(784.0L) + x * (static_cast(64.0L) + x))))))))) - }; - - return top / bot; -} - -template -constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(!(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54)), Real>::type -{ - // PadeApproximant[Log[x], {x, 1, {16, 16}}] - // FullSimplify[%] - - const Real - top - { - (static_cast(17.0L) * (static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(143327.0L) + x * (static_cast(25160192.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(1923749922816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(25160192.0L) + static_cast(143327.0L) * x))))))))))))))) - }; - - const Real - bot - { - (static_cast(360360.0L) * (static_cast(1.0L) + x * (static_cast(256.0L) + x * (static_cast(14400.0L) + x * (static_cast(313600.0L) + x * (static_cast(3312400.0L) + x * (static_cast(19079424.0L) + x * (static_cast(64128064.0L) + x * (static_cast(130873600.0L) + x * (static_cast(165636900.0L) + x * (static_cast(130873600.0L) + x * (static_cast(64128064.0L) + x * (static_cast(19079424.0L) + x * (static_cast(3312400.0L) + x * (static_cast(313600.0L) + x * (static_cast(14400.0L) + x * (static_cast(256.0L) + x))))))))))))))))) - }; - - return top / bot; -} - -// N[Log[2], 101] -// 0.69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641868754 - -template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 24), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } -template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 53), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } -template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 64), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } -#if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) -template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068Q); } -#else -template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } -#endif - -template -constexpr auto log_impl(Real x) noexcept -> Real +template +constexpr auto log_impl(T x) -> T { - int n2 { }; - - Real x2 { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::unsafe::frexp(x, &n2) }; - - if (x2 > static_cast(0.9L)) - { - x2 /= 2; - - ++n2; - } - - Real s { log_impl_pade(x2) }; - - Real E { exp_impl(s) }; - - // Do one single step of Newton-Raphson iteration. - s = s + ((x2 - E) / E); - - Real xn2 { static_cast(n2) * constant_ln_two() }; - - s += xn2; + // Default to the regular log function. + using std::log; - return s; + return log(x); } -// LCOV_EXCL_STOP } // namespace detail template constexpr auto log(Real x) -> Real { - if (BOOST_MP_IS_CONST_EVALUATED(x)) - { - return detail::log_impl(x); // LCOV_EXCL_LINE - } - else - { - using std::log; - - return log(x); - } + return cpp_df_qf_detail::ccmath::detail::log_impl(x); } -template -constexpr auto log_constexpr(Real x) -> Real -{ - return detail::log_impl(x); -} - -template -constexpr auto log_non_constexpr(Real x) -> Real -{ - using std::log; - - return log(x); -} - -} // namespace unsafe - } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 954e4199f..381570b91 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -13,15 +13,33 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { +namespace detail { + +template +constexpr auto sqrt_impl(T x) -> T +{ + // Default to the regular sqrt function. + using std::sqrt; + + return sqrt(x); +} + +} // namespace detail + +template +constexpr auto sqrt(Real x) -> Real +{ + return cpp_df_qf_detail::ccmath::detail::sqrt_impl(x); +} + namespace unsafe { namespace detail { -// LCOV_EXCL_START template constexpr auto sqrt_impl_2(Real x, Real s, Real s2) noexcept -> Real { - return ((!(s < s2)) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s)); + return !(s < s2) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s); } template @@ -35,27 +53,11 @@ constexpr auto sqrt_impl(Real x) noexcept -> Real { return sqrt_impl_1(x, x > 1 ? x : Real(1)); } -// LCOV_EXCL_STOP } // namespace detail template -constexpr auto sqrt(Real x) -> Real -{ - if (BOOST_MP_IS_CONST_EVALUATED(x)) - { - return detail::sqrt_impl(x); // LCOV_EXCL_LINE - } - else - { - using std::sqrt; - - return sqrt(x); - } -} - -template -constexpr auto sqrt_constexpr(Real x) -> Real +constexpr auto sqrt(Real x) noexcept -> Real { return detail::sqrt_impl(x); } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp index b4994a92a..fed468273 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp @@ -32,13 +32,13 @@ // 3.14159265358979323851281, -5.01655761266833202345176e-20 // 3.14159265358979323846264338327950279748, 8.67181013012378102479704402604335225411e-35 - template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } - template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } - template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } + template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } + template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } + template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } + template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } #else - template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } + template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } #endif // N[Log[2], 101] @@ -49,13 +49,13 @@ // 0.69314718055994530942869, -1.14583527267987328094768e-20 // 0.693147180559945309417232121458176575084, -7.00813947454958516341266200877162272784e-36 - template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } - template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } - template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } + template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } + template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } + template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } + template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } #else - template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } + template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } #endif // N[Exp[1], 101] @@ -66,13 +66,13 @@ // 2.71828182845904523521133, 1.4895979785582304563159e-19 // 2.71828182845904523536028747135266231436, 1.83398825226506410712297736767396397644e-34 - template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } - template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } - template constexpr auto constant_df_exp1()noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } + template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } + template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } + template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } + template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } #else - template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } + template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } #endif } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index ac3f4d944..830585a2a 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -739,9 +739,9 @@ class cpp_double_fp_backend // Handle overflow by scaling down (and then back up) with the split. hc = - cpp_df_qf_detail::ccmath::unsafe::ldexp + cpp_df_qf_detail::ccmath::ldexp ( - C - float_type { C - cpp_df_qf_detail::ccmath::unsafe::ldexp(C, -cpp_df_qf_detail::split_maker::n_shl) }, + C - float_type { C - cpp_df_qf_detail::ccmath::ldexp(C, -cpp_df_qf_detail::split_maker::n_shl) }, cpp_df_qf_detail::split_maker::n_shl ); } @@ -759,9 +759,9 @@ class cpp_double_fp_backend // Handle overflow by scaling down (and then back up) with the split. hv = - cpp_df_qf_detail::ccmath::unsafe::ldexp + cpp_df_qf_detail::ccmath::ldexp ( - v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, + v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, cpp_df_qf_detail::split_maker::n_shl ); } @@ -949,35 +949,21 @@ class cpp_double_fp_backend (cpp_df_qf_detail::ccmath::numeric_limits::max)() * ( static_cast(1.0F) - - ( - static_cast(1.5F) - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - * cpp_df_qf_detail::ccmath::unsafe::sqrt_constexpr - #else - * cpp_df_qf_detail::ccmath::unsafe::sqrt - #endif - ( - cpp_df_qf_detail::ccmath::numeric_limits::epsilon() - ) - ) + - static_cast(1.5F) * cpp_df_qf_detail::ccmath::unsafe::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) ) }; constexpr float_type lo_part { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr - #else cpp_df_qf_detail::ccmath::unsafe::ldexp - #endif ( (cpp_df_qf_detail::ccmath::numeric_limits::max)(), -cpp_df_qf_detail::ccmath::numeric_limits::digits ) }; - constexpr cpp_double_fp_backend my_value_max_constexpr(arithmetic::two_hilo_sum(hi_part, lo_part)); + constexpr cpp_double_fp_backend my_value_max_constexpr { arithmetic::two_hilo_sum(hi_part, lo_part) }; static_assert ( @@ -993,25 +979,19 @@ class cpp_double_fp_backend // Use the non-normalized minimum value, where the lower value // is "shifted" left in the sense of floating-point ldexp. - constexpr float_type - hi_part + constexpr cpp_double_fp_backend + my_value_min_constexpr { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr - #else cpp_df_qf_detail::ccmath::unsafe::ldexp - #endif ( (cpp_df_qf_detail::ccmath::numeric_limits::min)(), cpp_df_qf_detail::ccmath::numeric_limits::digits ) }; - constexpr cpp_double_fp_backend my_value_min_constexpr { hi_part }; - static_assert ( - eval_gt(my_value_min_constexpr, cpp_double_fp_backend((cpp_df_qf_detail::ccmath::numeric_limits::min)())), + eval_gt(my_value_min_constexpr, cpp_double_fp_backend { (cpp_df_qf_detail::ccmath::numeric_limits::min)() }), "Error: minimum value is too small and must exceed the min of its constituent type" ); @@ -1023,19 +1003,12 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_eps_constexpr { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr - #else - cpp_df_qf_detail::ccmath::unsafe::ldexp - #endif - ( - float_type { 1 }, int { 3 - my_digits } - ) + cpp_df_qf_detail::ccmath::unsafe::ldexp(float_type { 1 }, int { 3 - my_digits }) }; static_assert ( - eval_lt(cpp_double_fp_backend(1) - my_value_eps_constexpr, cpp_double_fp_backend(1)), + eval_lt(cpp_double_fp_backend { 1 } - my_value_eps_constexpr, cpp_double_fp_backend { 1 }), "Error: epsilon value is too small and must be large enough to differentiate (1 - epsilon) from 1" ); @@ -1052,36 +1025,6 @@ class cpp_double_fp_backend return cpp_double_fp_backend(static_cast(HUGE_VAL), float_type { 0.0F }); // conversion from double infinity OK } - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static auto my_value_logmax() noexcept -> const cpp_double_fp_backend& - #else - static constexpr auto my_value_logmax() noexcept -> cpp_double_fp_backend - #endif - { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static const cpp_double_fp_backend my_value_logmax_non_constexpr = my_value_logmax_maker(); - - return my_value_logmax_non_constexpr; - #else - return my_value_logmax_maker(); - #endif - } - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static auto my_value_logmin() noexcept -> const cpp_double_fp_backend& - #else - static constexpr auto my_value_logmin() noexcept -> cpp_double_fp_backend - #endif - { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - static const cpp_double_fp_backend my_value_logmin_non_constexpr = my_value_logmin_maker(); - - return my_value_logmin_non_constexpr; - #else - return my_value_logmin_maker(); - #endif - } - private: rep_type data; @@ -1092,130 +1035,6 @@ class cpp_double_fp_backend auto rd_string(const char* pstr) -> bool; - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - constexpr - #endif - static auto my_value_logmax_maker() noexcept -> cpp_double_fp_backend - { - // Here, we note that max is composed of (first + second), - // which we refactor as first * (1 + second / first). - - // We approximate log(first * (1 + second / first)) with - // log(first) + log(1 + second/first), and use a value of - // zero for the second logarithm. - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - const - #else - constexpr - #endif - float_type - first - { - (cpp_df_qf_detail::ccmath::numeric_limits::max)() - * ( - static_cast(1.0F) - - ( - static_cast(1.5F) - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - * cpp_df_qf_detail::ccmath::unsafe::sqrt_constexpr - #else - * cpp_df_qf_detail::ccmath::unsafe::sqrt - #endif - ( - cpp_df_qf_detail::ccmath::numeric_limits::epsilon() - ) - ) - ) - }; - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - const - #else - constexpr - #endif - cpp_double_fp_backend - my_value_logmax_constexpr_or_const - ( - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_non_constexpr(first)) - #else - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) - #endif - ); - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert - ( - eval_gt(my_value_logmax_constexpr_or_const, cpp_double_fp_backend(1)), - "Error: logmax value is definitely incorrect" - ); - #endif - - return my_value_logmax_constexpr_or_const; - } - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - constexpr - #endif - static auto my_value_logmin_maker() noexcept -> cpp_double_fp_backend - { - // Here, we note that min is composed of (first + second), - // which we refactor as first * (1 + second / first). - - // We approximate log(first * (1 + second / first)) with - // log(first) + log(1 + second/first), and use a value of - // zero for the second logarithm. - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - const - #else - constexpr - #endif - float_type - first - { - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_df_qf_detail::ccmath::unsafe::ldexp_constexpr - #else - cpp_df_qf_detail::ccmath::unsafe::ldexp - #endif - ( - (cpp_df_qf_detail::ccmath::numeric_limits::min)(), - cpp_df_qf_detail::ccmath::numeric_limits::digits - ) - }; - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - const - #else - constexpr - #endif - cpp_double_fp_backend - my_value_logmin_constexpr_or_const - ( - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log_non_constexpr(first)) - #else - cpp_double_fp_backend(cpp_df_qf_detail::ccmath::unsafe::log(first)) - #endif - ); - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert - ( - eval_lt(my_value_logmin_constexpr_or_const, cpp_double_fp_backend(-1)), - "Error: logmin value is definitely incorrect" - ); - #endif - - return my_value_logmin_constexpr_or_const; - } - constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void { // The multiplication algorithm has been taken from Victor Shoup, @@ -1232,9 +1051,9 @@ class cpp_double_fp_backend { // Handle overflow by scaling down (and then back up) with the split. - C = data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(data.first, -cpp_df_qf_detail::split_maker::n_shl); + C = data.first - cpp_df_qf_detail::ccmath::ldexp(data.first, -cpp_df_qf_detail::split_maker::n_shl); - hu = cpp_df_qf_detail::ccmath::unsafe::ldexp(data.first - C, cpp_df_qf_detail::split_maker::n_shl); + hu = cpp_df_qf_detail::ccmath::ldexp(data.first - C, cpp_df_qf_detail::split_maker::n_shl); } else { @@ -1266,9 +1085,9 @@ class cpp_double_fp_backend { // Handle overflow by scaling down (and then back up) with the split. - c = v.data.first - cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl); + c = v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl); - hv = cpp_df_qf_detail::ccmath::unsafe::ldexp(v.data.first - c, cpp_df_qf_detail::split_maker::n_shl); + hv = cpp_df_qf_detail::ccmath::ldexp(v.data.first - c, cpp_df_qf_detail::split_maker::n_shl); } else { @@ -1507,8 +1326,8 @@ constexpr auto eval_frexp(cpp_double_fp_backend& result, cons int expptr { }; - const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::frexp(a.rep().first, &expptr) }; - const local_float_type flo { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.rep().second, -expptr) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::frexp(a.rep().first, &expptr) }; + const local_float_type flo { cpp_df_qf_detail::ccmath::ldexp(a.rep().second, -expptr) }; if (v != nullptr) { @@ -1524,8 +1343,8 @@ constexpr auto eval_ldexp(cpp_double_fp_backend& result, cons using local_backend_type = cpp_double_fp_backend; using local_float_type = typename local_backend_type::float_type; - const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.crep().first, v) }; - const local_float_type flo { cpp_df_qf_detail::ccmath::unsafe::ldexp(a.crep().second, v) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::ldexp(a.crep().first, v) }; + const local_float_type flo { cpp_df_qf_detail::ccmath::ldexp(a.crep().second, v) }; result.rep() = local_backend_type::arithmetic::normalize(fhi, flo); } @@ -1536,7 +1355,7 @@ constexpr auto eval_floor(cpp_double_fp_backend& result, cons using local_backend_type = cpp_double_fp_backend; using local_float_type = typename local_backend_type::float_type; - const local_float_type fhi { cpp_df_qf_detail::ccmath::unsafe::floor(x.my_first()) }; + const local_float_type fhi { cpp_df_qf_detail::ccmath::floor(x.my_first()) }; if (fhi != x.my_first()) { @@ -1545,7 +1364,7 @@ constexpr auto eval_floor(cpp_double_fp_backend& result, cons } else { - const local_float_type flo = { cpp_df_qf_detail::ccmath::unsafe::floor(x.my_second()) }; + const local_float_type flo = { cpp_df_qf_detail::ccmath::floor(x.my_second()) }; result.rep() = local_backend_type::arithmetic::normalize(fhi, flo); } @@ -1619,7 +1438,7 @@ constexpr auto eval_sqrt(cpp_double_fp_backend& result, const // TBD: Do we need any overflow/underflow guards when multiplying // by the split or when multiplying (hx * tx) and/or (hx * hx)? - const local_float_type c { cpp_df_qf_detail::ccmath::unsafe::sqrt(o.crep().first) }; + const local_float_type c { cpp_df_qf_detail::ccmath::sqrt(o.crep().first) }; local_float_type p { cpp_df_qf_detail::split_maker::value * c }; @@ -1863,15 +1682,42 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. + const bool b_neg { x.isneg_unchecked() }; const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - if (eval_lt(x, double_float_type::my_value_logmin())) + const double_float_type max_exp_input + { + []() -> local_float_type + { + local_float_type mx { }; + eval_convert_to(&mx, double_float_type::my_value_max()); + + const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); + + return log_of_mx; + }() + }; + + const double_float_type min_exp_input + { + []() -> local_float_type + { + local_float_type mn { }; + eval_convert_to(&mn, double_float_type::my_value_min()); + + const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); + + return log_of_mn; + }() + }; + + if (eval_lt(x, min_exp_input)) { result = double_float_type(0U); } - else if (eval_gt(xx, double_float_type::my_value_logmax())) + else if (eval_gt(xx, max_exp_input)) { result = double_float_type::my_value_inf(); } @@ -1988,15 +1834,42 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. + const bool b_neg { x.isneg_unchecked() }; const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - if (eval_lt(x, double_float_type::my_value_logmin())) + const double_float_type max_exp_input + { + []() -> local_float_type + { + local_float_type mx { }; + eval_convert_to(&mx, double_float_type::my_value_max()); + + const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); + + return log_of_mx; + }() + }; + + const double_float_type min_exp_input + { + []() -> local_float_type + { + local_float_type mn { }; + eval_convert_to(&mn, double_float_type::my_value_min()); + + const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); + + return log_of_mn; + }() + }; + + if (eval_lt(x, min_exp_input)) { result = double_float_type(0U); } - else if (eval_gt(xx, double_float_type::my_value_logmax())) + else if (eval_gt(xx, max_exp_input)) { result = double_float_type::my_value_inf(); } @@ -2118,11 +1991,37 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - if (eval_lt(x, double_float_type::my_value_logmin())) + const double_float_type max_exp_input + { + []() -> local_float_type + { + local_float_type mx { }; + eval_convert_to(&mx, double_float_type::my_value_max()); + + const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); + + return log_of_mx; + }() + }; + + const double_float_type min_exp_input + { + []() -> local_float_type + { + local_float_type mn { }; + eval_convert_to(&mn, double_float_type::my_value_min()); + + const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); + + return log_of_mn; + }() + }; + + if (eval_lt(x, min_exp_input)) { result = double_float_type(0U); } - else if (eval_gt(xx, double_float_type::my_value_logmax())) + else if (eval_gt(xx, max_exp_input)) { result = double_float_type::my_value_inf(); } @@ -2256,7 +2155,7 @@ constexpr auto eval_log(cpp_double_fp_backend& result, const eval_frexp(x2, x, &n2); // Get initial estimate using the self-written, detail math function log. - const double_float_type s(cpp_df_qf_detail::ccmath::unsafe::log(x2.my_first())); + const double_float_type s(cpp_df_qf_detail::ccmath::log(x2.my_first())); double_float_type E { }; diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 0f21169af..85b4e0f58 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -13,47 +13,8 @@ #include "test_arithmetic.hpp" -void test_constexpr_ness() -{ - using boost::multiprecision::cpp_double_double; - - constexpr cpp_double_double one { 1 }; - - static_assert(static_cast(one) == 1, "Error: constexpr cpp_double_double construction failed"); - - BOOST_CHECK(static_cast(one) == 1); - - constexpr cpp_double_double dd_a { 1.23 }; - constexpr cpp_double_double dd_b { 4.56 }; - constexpr cpp_double_double dd_c { dd_a * dd_b }; - - constexpr cpp_double_double dd_s { sqrt(dd_a) }; - constexpr cpp_double_double sqrt_hundred { sqrt(cpp_double_double(100)) }; - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - const - #else - constexpr - #endif - cpp_double_double log_hundred { log(cpp_double_double(100)) }; - - static_assert(dd_c > 5, "Error in constexpr multiplication"); - static_assert(dd_s > 1, "Error in constexpr square root"); - static_assert(sqrt_hundred == 10, "Error in constexpr square root"); - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert(log_hundred > 4.605, "Error in constexpr logarithm"); - #endif - - BOOST_CHECK(dd_c > 5); - BOOST_CHECK(dd_s > 1); - BOOST_CHECK(sqrt_hundred == 10); - BOOST_CHECK(log_hundred > 4.605); -} - int main() { - ::test_constexpr_ness(); - using boost::multiprecision::cpp_double_float; using boost::multiprecision::cpp_double_double; using boost::multiprecision::cpp_double_long_double; @@ -61,6 +22,10 @@ int main() using boost::multiprecision::cpp_double_float128; #endif + constexpr cpp_double_double one { 1 }; + + static_assert(static_cast(one) == 1, "Error:constexpr-ness of cpp_double_double constructor failed"); + test(); test(); test(); diff --git a/test/test_round.cpp b/test/test_round.cpp index 41dc12a8d..c57bd4d8a 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -510,15 +510,12 @@ int main() test(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT -#if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) -#else test(); test(); test(); #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif -#endif #endif return boost::report_errors(); diff --git a/test/test_various_edges.cpp b/test/test_various_edges.cpp index 145ecaa0b..c3b5de4ff 100644 --- a/test/test_various_edges.cpp +++ b/test/test_various_edges.cpp @@ -1418,6 +1418,9 @@ namespace local } #ifdef BOOST_HAS_INT128 + + #define BOOST_MP_TEST_DISABLE_INT128_NON_FINITE + constexpr bool is_24_digit_float { (std::numeric_limits::digits == 24) }; constexpr bool is_cpp_double_float @@ -1427,7 +1430,6 @@ namespace local BOOST_IF_CONSTEXPR(is_24_digit_float && is_cpp_double_float) { - #if 0 for(auto index = 0U; index < 8U; ++index) { using std::ldexp; @@ -1487,23 +1489,37 @@ namespace local const auto result_val_uinf_is_ok = (u128_inf == static_cast(std::numeric_limits::infinity())); const auto result_val_uzer_is_ok = (u128_zer == static_cast(0)); + #if defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) + static_cast(result_val_nan_is_ok); + static_cast(result_val_inf_is_ok); + static_cast(result_val_unan_is_ok); + static_cast(result_val_uinf_is_ok); + #endif + + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) BOOST_TEST(result_val_nan_is_ok); BOOST_TEST(result_val_inf_is_ok); + #endif BOOST_TEST(result_val_zer_is_ok); + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) BOOST_TEST(result_val_unan_is_ok); BOOST_TEST(result_val_uinf_is_ok); + #endif BOOST_TEST(result_val_uzer_is_ok); + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) result_is_ok = (result_val_nan_is_ok && result_is_ok); result_is_ok = (result_val_inf_is_ok && result_is_ok); + #endif result_is_ok = (result_val_zer_is_ok && result_is_ok); + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) result_is_ok = (result_val_unan_is_ok && result_is_ok); result_is_ok = (result_val_uinf_is_ok && result_is_ok); + #endif result_is_ok = (result_val_uzer_is_ok && result_is_ok); } - #endif } else { @@ -1575,39 +1591,44 @@ namespace local const boost::int128_type n128_inf { static_cast(flt_inf) }; const boost::int128_type n128_zer { static_cast(flt_zer) }; - #define BOOST_MP_TEST_DISABLE_U128_NON_FINITE - - #if !defined(BOOST_MP_TEST_DISABLE_U128_NON_FINITE) const boost::uint128_type u128_nan { static_cast(flt_nan) }; const boost::uint128_type u128_inf { static_cast(flt_inf) }; - #endif const boost::uint128_type u128_zer { static_cast(flt_zer) }; const auto result_val_nan_is_ok = (n128_nan == static_cast(std::numeric_limits::quiet_NaN())); const auto result_val_inf_is_ok = (n128_inf == static_cast(std::numeric_limits::infinity())); const auto result_val_zer_is_ok = (n128_zer == static_cast(0)); - #if !defined(BOOST_MP_TEST_DISABLE_U128_NON_FINITE) const auto result_val_unan_is_ok = (u128_nan == static_cast(std::numeric_limits::quiet_NaN())); const auto result_val_uinf_is_ok = (u128_inf == static_cast(std::numeric_limits::infinity())); - #endif const auto result_val_uzer_is_ok = (u128_zer == static_cast(0)); + #if defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) + static_cast(result_val_nan_is_ok); + static_cast(result_val_inf_is_ok); + static_cast(result_val_unan_is_ok); + static_cast(result_val_uinf_is_ok); + #endif + + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) BOOST_TEST(result_val_nan_is_ok); BOOST_TEST(result_val_inf_is_ok); + #endif BOOST_TEST(result_val_zer_is_ok); - #if !defined(BOOST_MP_TEST_DISABLE_U128_NON_FINITE) + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) BOOST_TEST(result_val_unan_is_ok); BOOST_TEST(result_val_uinf_is_ok); #endif BOOST_TEST(result_val_uzer_is_ok); + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) result_is_ok = (result_val_nan_is_ok && result_is_ok); result_is_ok = (result_val_inf_is_ok && result_is_ok); + #endif result_is_ok = (result_val_zer_is_ok && result_is_ok); - #if !defined(BOOST_MP_TEST_DISABLE_U128_NON_FINITE) + #if !defined(BOOST_MP_TEST_DISABLE_INT128_NON_FINITE) result_is_ok = (result_val_unan_is_ok && result_is_ok); result_is_ok = (result_val_uinf_is_ok && result_is_ok); #endif From 5206da6c71fa6eb8485768bd2746f2fb39290ab3 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 31 Aug 2025 15:00:57 +0200 Subject: [PATCH 070/114] Simplify exponent functions --- .../cpp_df_qf_detail_ccmath_frexp.hpp | 71 +++++++++-- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 63 ++++++---- .../cpp_df_qf/cpp_df_qf_detail_constants.hpp | 30 ++--- .../boost/multiprecision/cpp_double_fp.hpp | 110 ++++-------------- 4 files changed, 142 insertions(+), 132 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp index 2ca53f32c..dcb96303e 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_frexp.hpp @@ -13,24 +13,79 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -namespace detail -{ +namespace detail { -template -constexpr auto frexp_impl(T arg, int* expptr) -> T +// LCOV_EXCL_START +template +constexpr auto frexp_impl(Real arg, int* expptr) noexcept -> Real { - // Default to the regular frexp function. - using std::frexp; + const bool negative_arg { (arg < static_cast(0)) }; + + Real f { negative_arg ? -arg : arg }; + + int e2 { }; + + constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; + + while (f >= two_pow_16_plus) + { + f = f / two_pow_16_plus; + e2 += 16; + } + + constexpr Real two_pow_16_minus { static_cast(0.0000152587890625L) }; - return frexp(arg, expptr); + while (f <= two_pow_16_minus) + { + f = f * two_pow_16_plus; + e2 -= 16; + } + + while(f >= static_cast(INT8_C(1))) + { + f = f / static_cast(INT8_C(2)); + ++e2; + } + + while(f < static_cast(0.5L)) + { + f = f * static_cast(INT8_C(2)); + --e2; + } + + *expptr = e2; + + return ((!negative_arg) ? f : -f); } +// LCOV_EXCL_STOP } // namespace detail template constexpr auto frexp(Real arg, int* expptr) -> Real { - return detail::frexp_impl(arg, expptr); + if (BOOST_MP_IS_CONST_EVALUATED(arg)) + { + // LCOV_EXCL_START + if (arg == static_cast(0)) + { + *expptr = 0; + + return arg; + } + else + { + return detail::frexp_impl(arg, expptr); + } + // LCOV_EXCL_STOP + } + else + { + // Default to the regular frexp function. + using std::frexp; + + return frexp(arg, expptr); + } } } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index da2510969..f30695062 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -15,43 +15,62 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_ namespace detail { -template -constexpr auto ldexp_impl(T arg, int expval) -> T +// LCOV_EXCL_START +template +constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real { - // Default to the regular ldexp function. - using std::ldexp; + constexpr Real two_pow_16_plus { static_cast(INT32_C(0x10000)) }; - return ldexp(arg, expval); -} + while(expval > 16) + { + arg *= two_pow_16_plus; + expval -= 16; + } -} // Namespace detail + while(expval < -16) + { + arg /= two_pow_16_plus; + expval += 16; + } -template -constexpr auto ldexp(Real arg, int expval) -> Real -{ - return detail::ldexp_impl(arg, expval); + while(expval > 0) + { + arg *= 2; + --expval; + } + + while(expval < 0) + { + arg /= 2; + ++expval; + } + + return arg; } +// LCOV_EXCL_STOP -namespace unsafe { +} // Namespace detail template -constexpr auto ldexp(Real arg, int exp) noexcept -> Real +constexpr auto ldexp(Real arg, int expval) -> Real { - while(exp > 0) + if (BOOST_MP_IS_CONST_EVALUATED(arg)) { - arg *= 2; - --exp; + return detail::ldexp_impl(arg, expval); // LCOV_EXCL_LINE } - while(exp < 0) + else { - arg /= 2; - ++exp; - } + using std::ldexp; - return arg; + return ldexp(arg, expval); + } } -} // namespace unsafe +template +constexpr auto ldexp_constexpr(Real arg, int expval) -> Real +{ + return detail::ldexp_impl(arg, expval); +} } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp index fed468273..6fed97547 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp @@ -32,13 +32,13 @@ // 3.14159265358979323851281, -5.01655761266833202345176e-20 // 3.14159265358979323846264338327950279748, 8.67181013012378102479704402604335225411e-35 - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(3.14159250259L), static_cast(1.50995788317e-07L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(3.141592653589793116L), static_cast(1.2246467991473529607e-16L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323851281L), static_cast(-5.01655761266833202345176e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748Q), static_cast(8.67181013012378102479704402604335225411e-35Q) }; } #else - template constexpr auto constant_df_pi() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } + template constexpr auto constant_df_pi() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(3.14159265358979323846264338327950279748L), static_cast(8.67181013012378102479704402604335225411e-35L) }; } #endif // N[Log[2], 101] @@ -49,13 +49,13 @@ // 0.69314718055994530942869, -1.14583527267987328094768e-20 // 0.693147180559945309417232121458176575084, -7.00813947454958516341266200877162272784e-36 - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(0.69314712286L), static_cast(5.76999887869e-08L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(0.6931471805599451752L), static_cast(1.3421277060097865271e-16L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(0.69314718055994530942869L), static_cast(-1.14583527267987328094768e-20L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084Q), static_cast(-7.00813947454958516341266200877162272784e-36Q) }; } #else - template constexpr auto constant_df_ln_two() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } + template constexpr auto constant_df_ln_two() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(0.693147180559945309417232121458176575084L), static_cast(-7.00813947454958516341266200877162272784e-36L) }; } #endif // N[Exp[1], 101] @@ -66,13 +66,13 @@ // 2.71828182845904523521133, 1.4895979785582304563159e-19 // 2.71828182845904523536028747135266231436, 1.83398825226506410712297736767396397644e-34 - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 24)), cpp_double_fp_backend>::type { return { static_cast(2.71828174591L), static_cast(8.25483965627e-08L) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 53)), cpp_double_fp_backend>::type { return { static_cast(2.7182818284590450908L), static_cast(1.4456468917292501578e-16L) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 64)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523521133L), static_cast(1.4895979785582304563159e-19L) }; } #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436Q), static_cast(1.83398825226506410712297736767396397644e-34Q) }; } #else - template constexpr auto constant_df_exp1() -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } + template constexpr auto constant_df_exp1() noexcept -> typename ::std::enable_if<(cpp_df_qf_detail::is_floating_point::value && (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113)), cpp_double_fp_backend>::type { return { static_cast(2.71828182845904523536028747135266231436L), static_cast(1.83398825226506410712297736767396397644e-34L) }; } #endif } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 830585a2a..4d10b8354 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -956,7 +956,7 @@ class cpp_double_fp_backend constexpr float_type lo_part { - cpp_df_qf_detail::ccmath::unsafe::ldexp + cpp_df_qf_detail::ccmath::ldexp ( (cpp_df_qf_detail::ccmath::numeric_limits::max)(), -cpp_df_qf_detail::ccmath::numeric_limits::digits @@ -982,7 +982,7 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_min_constexpr { - cpp_df_qf_detail::ccmath::unsafe::ldexp + cpp_df_qf_detail::ccmath::ldexp ( (cpp_df_qf_detail::ccmath::numeric_limits::min)(), cpp_df_qf_detail::ccmath::numeric_limits::digits @@ -1003,7 +1003,7 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_eps_constexpr { - cpp_df_qf_detail::ccmath::unsafe::ldexp(float_type { 1 }, int { 3 - my_digits }) + cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits }) }; static_assert @@ -1025,6 +1025,20 @@ class cpp_double_fp_backend return cpp_double_fp_backend(static_cast(HUGE_VAL), float_type { 0.0F }); // conversion from double infinity OK } + static auto my_value_logmax() -> const cpp_double_fp_backend& + { + static const cpp_double_fp_backend lg_max(float_type(cpp_df_qf_detail::ccmath::log(my_value_max().my_first()))); + + return lg_max; + } + + static auto my_value_logmin() -> const cpp_double_fp_backend& + { + static const cpp_double_fp_backend lg_min(float_type(cpp_df_qf_detail::ccmath::log(my_value_min().my_first()))); + + return lg_min; + } + private: rep_type data; @@ -1687,37 +1701,11 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } @@ -1839,37 +1827,11 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } @@ -1991,37 +1953,11 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. - const double_float_type max_exp_input - { - []() -> local_float_type - { - local_float_type mx { }; - eval_convert_to(&mx, double_float_type::my_value_max()); - - const local_float_type log_of_mx = cpp_df_qf_detail::ccmath::log(mx); - - return log_of_mx; - }() - }; - - const double_float_type min_exp_input - { - []() -> local_float_type - { - local_float_type mn { }; - eval_convert_to(&mn, double_float_type::my_value_min()); - - const local_float_type log_of_mn = cpp_df_qf_detail::ccmath::log(mn); - - return log_of_mn; - }() - }; - - if (eval_lt(x, min_exp_input)) + if (eval_lt(x, double_float_type::my_value_logmin())) { result = double_float_type(0U); } - else if (eval_gt(xx, max_exp_input)) + else if (eval_gt(xx, double_float_type::my_value_logmax())) { result = double_float_type::my_value_inf(); } From dba4d8a42586a8dbe18fb3c44338b99c3eaa8b6b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 31 Aug 2025 15:27:09 +0200 Subject: [PATCH 071/114] Reduce constexpr reqs for old GCC --- .../boost/multiprecision/cpp_double_fp.hpp | 29 ++++++++++++------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 4d10b8354..f2e2508a3 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -963,13 +963,16 @@ class cpp_double_fp_backend ) }; - constexpr cpp_double_fp_backend my_value_max_constexpr { arithmetic::two_hilo_sum(hi_part, lo_part) }; + constexpr cpp_double_fp_backend my_value_max_constexpr(arithmetic::two_hilo_sum(hi_part, lo_part)); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else static_assert ( - eval_gt(my_value_max_constexpr, cpp_double_fp_backend { hi_part }), + eval_gt(my_value_max_constexpr, cpp_double_fp_backend(hi_part)), "Error: maximum value is too small in relation to the maximum of its constituent type" ); + #endif return my_value_max_constexpr; } @@ -981,19 +984,22 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend my_value_min_constexpr - { + ( cpp_df_qf_detail::ccmath::ldexp ( (cpp_df_qf_detail::ccmath::numeric_limits::min)(), cpp_df_qf_detail::ccmath::numeric_limits::digits ) - }; + ); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else static_assert ( - eval_gt(my_value_min_constexpr, cpp_double_fp_backend { (cpp_df_qf_detail::ccmath::numeric_limits::min)() }), + eval_gt(my_value_min_constexpr, cpp_double_fp_backend((cpp_df_qf_detail::ccmath::numeric_limits::min)())), "Error: minimum value is too small and must exceed the min of its constituent type" ); + #endif return my_value_min_constexpr; } @@ -1002,27 +1008,30 @@ class cpp_double_fp_backend { constexpr cpp_double_fp_backend my_value_eps_constexpr - { + ( cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits }) - }; + ); + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else static_assert ( - eval_lt(cpp_double_fp_backend { 1 } - my_value_eps_constexpr, cpp_double_fp_backend { 1 }), + eval_lt(cpp_double_fp_backend(1) - my_value_eps_constexpr, cpp_double_fp_backend(1)), "Error: epsilon value is too small and must be large enough to differentiate (1 - epsilon) from 1" ); + #endif return my_value_eps_constexpr; } static constexpr auto my_value_nan() noexcept -> cpp_double_fp_backend { - return cpp_double_fp_backend(static_cast(NAN), float_type { 0.0F }); + return cpp_double_fp_backend(static_cast(NAN), static_cast(0.0F)); } static constexpr auto my_value_inf() noexcept -> cpp_double_fp_backend { - return cpp_double_fp_backend(static_cast(HUGE_VAL), float_type { 0.0F }); // conversion from double infinity OK + return cpp_double_fp_backend(static_cast(HUGE_VAL), static_cast(0.0F)); // conversion from double infinity OK } static auto my_value_logmax() -> const cpp_double_fp_backend& From 4cb7deea3d10ad888fdd2c7695139ceb0a292cce Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 31 Aug 2025 18:09:06 +0200 Subject: [PATCH 072/114] Explore furthe constexpr reductions --- .../boost/multiprecision/cpp_double_fp.hpp | 77 +++++++------------ 1 file changed, 26 insertions(+), 51 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index f2e2508a3..eafeb5b48 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -938,51 +938,44 @@ class cpp_double_fp_backend return e2; } - static constexpr auto my_value_max() noexcept -> cpp_double_fp_backend + static auto my_value_max() noexcept -> const cpp_double_fp_backend& { // Use the non-normalized sum of two maximum values, where the lower // value is "shifted" right in the sense of floating-point ldexp. - constexpr float_type - hi_part - { - (cpp_df_qf_detail::ccmath::numeric_limits::max)() - * ( - static_cast(1.0F) - - static_cast(1.5F) * cpp_df_qf_detail::ccmath::unsafe::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) - ) - }; - - constexpr float_type - lo_part - { - cpp_df_qf_detail::ccmath::ldexp + static const cpp_double_fp_backend + my_value_max_constexpr + ( + arithmetic::two_hilo_sum ( - (cpp_df_qf_detail::ccmath::numeric_limits::max)(), - -cpp_df_qf_detail::ccmath::numeric_limits::digits + float_type + { + (cpp_df_qf_detail::ccmath::numeric_limits::max)() + * ( + static_cast(1.0F) + - static_cast(1.5F) * cpp_df_qf_detail::ccmath::unsafe::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + ) + }, + float_type + { + cpp_df_qf_detail::ccmath::ldexp + ( + (cpp_df_qf_detail::ccmath::numeric_limits::max)(), + -cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + } ) - }; - - constexpr cpp_double_fp_backend my_value_max_constexpr(arithmetic::two_hilo_sum(hi_part, lo_part)); - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert - ( - eval_gt(my_value_max_constexpr, cpp_double_fp_backend(hi_part)), - "Error: maximum value is too small in relation to the maximum of its constituent type" - ); - #endif + ); return my_value_max_constexpr; } - static constexpr auto my_value_min() noexcept -> cpp_double_fp_backend + static auto my_value_min() noexcept -> const cpp_double_fp_backend& { // Use the non-normalized minimum value, where the lower value // is "shifted" left in the sense of floating-point ldexp. - constexpr cpp_double_fp_backend + static const cpp_double_fp_backend my_value_min_constexpr ( cpp_df_qf_detail::ccmath::ldexp @@ -992,35 +985,17 @@ class cpp_double_fp_backend ) ); - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert - ( - eval_gt(my_value_min_constexpr, cpp_double_fp_backend((cpp_df_qf_detail::ccmath::numeric_limits::min)())), - "Error: minimum value is too small and must exceed the min of its constituent type" - ); - #endif - return my_value_min_constexpr; } - static constexpr auto my_value_eps() noexcept -> cpp_double_fp_backend + static auto my_value_eps() noexcept -> const cpp_double_fp_backend& { - constexpr cpp_double_fp_backend + static const cpp_double_fp_backend my_value_eps_constexpr ( cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits }) ); - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else - static_assert - ( - eval_lt(cpp_double_fp_backend(1) - my_value_eps_constexpr, cpp_double_fp_backend(1)), - "Error: epsilon value is too small and must be large enough to differentiate (1 - epsilon) from 1" - ); - #endif - return my_value_eps_constexpr; } From 07868397203e1f9fecb8be82041a3bbe28364e53 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 31 Aug 2025 20:22:41 +0200 Subject: [PATCH 073/114] Simplify syntax with tmp run-time perf loss --- .../boost/multiprecision/cpp_double_fp.hpp | 44 +++++++------------ 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index eafeb5b48..4ca78984d 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -938,13 +938,12 @@ class cpp_double_fp_backend return e2; } - static auto my_value_max() noexcept -> const cpp_double_fp_backend& + static constexpr auto my_value_max() noexcept -> cpp_double_fp_backend { // Use the non-normalized sum of two maximum values, where the lower // value is "shifted" right in the sense of floating-point ldexp. - static const cpp_double_fp_backend - my_value_max_constexpr + return cpp_double_fp_backend ( arithmetic::two_hilo_sum ( @@ -966,37 +965,32 @@ class cpp_double_fp_backend } ) ); - - return my_value_max_constexpr; } - static auto my_value_min() noexcept -> const cpp_double_fp_backend& + static constexpr auto my_value_min() noexcept -> cpp_double_fp_backend { // Use the non-normalized minimum value, where the lower value // is "shifted" left in the sense of floating-point ldexp. - static const cpp_double_fp_backend - my_value_min_constexpr + return cpp_double_fp_backend ( - cpp_df_qf_detail::ccmath::ldexp + float_type ( - (cpp_df_qf_detail::ccmath::numeric_limits::min)(), - cpp_df_qf_detail::ccmath::numeric_limits::digits + cpp_df_qf_detail::ccmath::ldexp + ( + (cpp_df_qf_detail::ccmath::numeric_limits::min)(), + cpp_df_qf_detail::ccmath::numeric_limits::digits + ) ) ); - - return my_value_min_constexpr; } - static auto my_value_eps() noexcept -> const cpp_double_fp_backend& + static constexpr auto my_value_eps() noexcept -> cpp_double_fp_backend { - static const cpp_double_fp_backend - my_value_eps_constexpr + return cpp_double_fp_backend ( - cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits }) + float_type(cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits })) ); - - return my_value_eps_constexpr; } static constexpr auto my_value_nan() noexcept -> cpp_double_fp_backend @@ -1009,18 +1003,14 @@ class cpp_double_fp_backend return cpp_double_fp_backend(static_cast(HUGE_VAL), static_cast(0.0F)); // conversion from double infinity OK } - static auto my_value_logmax() -> const cpp_double_fp_backend& + static constexpr auto my_value_logmax() -> cpp_double_fp_backend { - static const cpp_double_fp_backend lg_max(float_type(cpp_df_qf_detail::ccmath::log(my_value_max().my_first()))); - - return lg_max; + return float_type(cpp_df_qf_detail::ccmath::log(my_value_max().my_first())); } - static auto my_value_logmin() -> const cpp_double_fp_backend& + static constexpr auto my_value_logmin() -> cpp_double_fp_backend { - static const cpp_double_fp_backend lg_min(float_type(cpp_df_qf_detail::ccmath::log(my_value_min().my_first()))); - - return lg_min; + return float_type(cpp_df_qf_detail::ccmath::log(my_value_min().my_first())); } private: From e7527eeb0cd0abe7001d4859905e8118575820cd Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 12:42:26 +0200 Subject: [PATCH 074/114] Square root optionally constexpr-eval --- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 2 +- .../cpp_df_qf_detail_ccmath_sqrt.hpp | 42 ++++++++----------- .../boost/multiprecision/cpp_double_fp.hpp | 2 +- 3 files changed, 20 insertions(+), 26 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index f30695062..bfa4e00ef 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -52,7 +52,7 @@ constexpr auto ldexp_impl(Real arg, int expval) noexcept -> Real } // Namespace detail template -constexpr auto ldexp(Real arg, int expval) -> Real +constexpr auto ldexp(Real arg, int expval) noexcept -> Real { if (BOOST_MP_IS_CONST_EVALUATED(arg)) { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 381570b91..7c9aac5fb 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -15,31 +15,11 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_ namespace detail { -template -constexpr auto sqrt_impl(T x) -> T -{ - // Default to the regular sqrt function. - using std::sqrt; - - return sqrt(x); -} - -} // namespace detail - -template -constexpr auto sqrt(Real x) -> Real -{ - return cpp_df_qf_detail::ccmath::detail::sqrt_impl(x); -} - -namespace unsafe { - -namespace detail { - +// LCOV_EXCL_START template constexpr auto sqrt_impl_2(Real x, Real s, Real s2) noexcept -> Real { - return !(s < s2) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s); + return ((!(s < s2)) ? s2 : sqrt_impl_2(x, (x / s + s) / 2, s)); } template @@ -53,16 +33,30 @@ constexpr auto sqrt_impl(Real x) noexcept -> Real { return sqrt_impl_1(x, x > 1 ? x : Real(1)); } +// LCOV_EXCL_STOP } // namespace detail template constexpr auto sqrt(Real x) noexcept -> Real { - return detail::sqrt_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::sqrt_impl(x); // LCOV_EXCL_LINE + } + else + { + using std::sqrt; + + return sqrt(x); + } } -} // namespace unsafe +template +constexpr auto sqrt_constexpr(Real x) -> Real +{ + return detail::sqrt_impl(x); +} } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 4ca78984d..ce04767e9 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -952,7 +952,7 @@ class cpp_double_fp_backend (cpp_df_qf_detail::ccmath::numeric_limits::max)() * ( static_cast(1.0F) - - static_cast(1.5F) * cpp_df_qf_detail::ccmath::unsafe::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + - static_cast(1.5F) * cpp_df_qf_detail::ccmath::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) ) }, float_type From 82da79c99d7a01bdd7180a12e2e62cc431d9fc4c Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 13:36:08 +0200 Subject: [PATCH 075/114] Add more constexpr-ness --- .../cpp_df_qf_detail_ccmath_fabs.hpp | 2 +- .../cpp_df_qf_detail_ccmath_floor.hpp | 91 +++++++++++++++++-- .../cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp | 54 ++++++----- .../cpp_df_qf_detail_ccmath_fpclassify.hpp | 11 ++- .../cpp_df_qf_detail_ccmath_isnan.hpp | 2 +- .../cpp_df_qf_detail_ccmath_ldexp.hpp | 6 -- .../boost/multiprecision/cpp_double_fp.hpp | 4 - test/test_arithmetic_df.cpp | 47 +++++++--- 8 files changed, 157 insertions(+), 60 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp index cfd3b5260..f71ef3501 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fabs.hpp @@ -14,7 +14,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto fabs(Real x) -> Real +constexpr auto fabs(Real x) noexcept -> Real { return (cpp_df_qf_detail::ccmath::isnan(x)) ? cpp_df_qf_detail::ccmath::numeric_limits::quiet_NaN() : (x == static_cast(-0)) ? static_cast(0) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp index 4df2f46a3..b4a560fe4 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp @@ -8,6 +8,8 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_FLOOR_2024_12_30_HPP +#include + #include #include @@ -15,21 +17,98 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_ namespace detail { -template -constexpr auto floor_impl(T x) -> T +// LCOV_EXCL_START +template +constexpr auto floor_pos_impl(Real arg) noexcept -> Real { - // Default to the regular floor function. - using std::floor; + constexpr auto + max_comp_val + { + Real(1) / ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::epsilon() + }; + + if (arg >= max_comp_val) + { + return arg; + } + + Real result { 1 }; + + if(result <= arg) + { + while(result < arg) + { + result *= 2; + } - return floor(x); + while(result > arg) + { + --result; + } + + return result; + } + else + { + return Real(0); + } } +template +constexpr auto floor_neg_impl(Real arg) noexcept -> Real +{ + Real result { -1 }; + + if(result > arg) + { + while(result > arg) + { + result *= 2; + } + + while(result < arg) + { + ++result; + } + + if(result != arg) + { + --result; + } + } + + return result; +} + +template +constexpr auto floor_impl(Real arg) noexcept -> Real +{ + if(arg > 0) + { + return floor_pos_impl(arg); + } + else + { + return floor_neg_impl(arg); + } +} +// LCOV_EXCL_STOP + } // namespace detail template constexpr auto floor(Real x) -> Real { - return cpp_df_qf_detail::ccmath::detail::floor_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::floor_impl(x); // LCOV_EXCL_LINE + } + else + { + using std::floor; + + return floor(x); + } } } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp index f7117c8c2..1ac41d661 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp @@ -17,41 +17,45 @@ namespace unsafe { namespace detail { -template -constexpr auto fma_impl(T x, T y, T z) noexcept -> T +// LCOV_EXCL_START +template +constexpr auto fma_impl(const Real x, const Real y, const Real z) noexcept -> Real { - // Default to the written-out operations ... - // ... and hope the compiler chooses FMA if available). + #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) + BOOST_IF_CONSTEXPR (std::is_same::value) + { + return __builtin_fmaf(x, y, z); + } + else BOOST_IF_CONSTEXPR (std::is_same::value) + { + return __builtin_fma(x, y, z); + } + else BOOST_IF_CONSTEXPR (std::is_same::value) + { + return __builtin_fmal(x, y, z); + } + #endif + // If we can't use compiler intrinsics hope that -fma flag optimizes this call to fma instruction return (x * y) + z; } - -#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__INTEL_LLVM_COMPILER) -template <> -constexpr auto fma_impl(float x, float y, float z) noexcept -> float -{ - return __builtin_fmaf(x, y, z); -} - -template <> -constexpr auto fma_impl(double x, double y, double z) noexcept -> double -{ - return __builtin_fma(x, y, z); -} - -template <> -constexpr auto fma_impl(long double x, long double y, long double z) noexcept -> long double -{ - return __builtin_fmal(x, y, z); -} -#endif +// LCOV_EXCL_STOP } // namespace detail template constexpr auto fma(Real x, Real y, Real z) noexcept -> Real { - return detail::fma_impl(x, y, z); + if (BOOST_MP_IS_CONST_EVALUATED(x) && BOOST_MP_IS_CONST_EVALUATED(y) && BOOST_MP_IS_CONST_EVALUATED(z)) + { + return detail::fma_impl(x, y, z); // LCOV_EXCL_LINE + } + else + { + using std::fma; + + return fma(x, y, z); + } } } // namespace unsafe diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp index 7824e99ad..d378094d5 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp @@ -11,13 +11,14 @@ #include #include #include +#include #include namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { -template -constexpr auto fpclassify(T x) -> int +template +constexpr auto fpclassify(Real x) noexcept -> int { if ((::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::isnan)(x)) { @@ -29,13 +30,13 @@ constexpr auto fpclassify(T x) -> int } else { - const T fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; + const Real fabs_x { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::fabs(x) }; - if (fabs_x == T(0)) + if (fabs_x == Real(0)) { return FP_ZERO; } - else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) + else if ((fabs_x > 0) && (fabs_x < (::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::min)())) { return FP_SUBNORMAL; } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp index 468a97b97..4e45ff60f 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_isnan.hpp @@ -11,7 +11,7 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { template -constexpr auto isnan(FloatingPointType x) -> bool +constexpr auto isnan(FloatingPointType x) noexcept -> bool { return (x != x); } diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp index bfa4e00ef..38ba034b6 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_ldexp.hpp @@ -66,12 +66,6 @@ constexpr auto ldexp(Real arg, int expval) noexcept -> Real } } -template -constexpr auto ldexp_constexpr(Real arg, int expval) -> Real -{ - return detail::ldexp_impl(arg, expval); -} - } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LDEXP_2023_01_07_HPP diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index ce04767e9..2c99be49b 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1670,8 +1670,6 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. - const bool b_neg { x.isneg_unchecked() }; - const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. @@ -1796,8 +1794,6 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const using local_float_type = typename double_float_type::float_type; // Get a local copy of the argument and force it to be positive. - const bool b_neg { x.isneg_unchecked() }; - const double_float_type xx { (!b_neg) ? x : -x }; // Check the range of the input. diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 85b4e0f58..83bb53487 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -13,24 +13,47 @@ #include "test_arithmetic.hpp" +template +auto test_constexpr_ness() noexcept -> void +{ + using local_float_type = FloatType; + + constexpr local_float_type one { 1 }; + + static_assert(static_cast(one) == 1, "Error: constexpr local_float_type construction failed"); + + BOOST_CHECK(static_cast(one) == 1); + + constexpr local_float_type dd_a { 1.23 }; + constexpr local_float_type dd_b { 4.56 }; + constexpr local_float_type dd_c { dd_a * dd_b }; + + constexpr local_float_type dd_s { sqrt(dd_a) }; + constexpr local_float_type sqrt_hundred { sqrt(local_float_type(100)) }; + + static_assert(dd_c > 5, "Error in constexpr multiplication"); + static_assert(dd_s > 1, "Error in constexpr square root"); + static_assert(sqrt_hundred == 10, "Error in constexpr square root"); + + BOOST_CHECK(dd_c > 5); + BOOST_CHECK(dd_s > 1); + BOOST_CHECK(sqrt_hundred == 10); +} + int main() { - using boost::multiprecision::cpp_double_float; - using boost::multiprecision::cpp_double_double; - using boost::multiprecision::cpp_double_long_double; + ::test_constexpr_ness(); + ::test_constexpr_ness(); + ::test_constexpr_ness(); #ifdef BOOST_HAS_FLOAT128 - using boost::multiprecision::cpp_double_float128; + ::test_constexpr_ness(); #endif - constexpr cpp_double_double one { 1 }; - - static_assert(static_cast(one) == 1, "Error:constexpr-ness of cpp_double_double constructor failed"); - - test(); - test(); - test(); + test(); + test(); + test(); #ifdef BOOST_HAS_FLOAT128 - test(); + test(); #endif return boost::report_errors(); } From 62cb7cdd6d3e25b74302c87e5df3bb6612bba908 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 14:57:27 +0200 Subject: [PATCH 076/114] Try finishing constexpr-ness --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 146 +++++++++++++++++- .../cpp_df_qf_detail_ccmath_sqrt.hpp | 6 - .../boost/multiprecision/cpp_double_fp.hpp | 69 ++++++--- test/test_arithmetic_df.cpp | 3 + 4 files changed, 193 insertions(+), 31 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 64cd301ed..d1ce84045 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -8,28 +8,162 @@ #ifndef BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP #define BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_LOG_2024_12_30_HPP +#include +#include + #include #include +#if (defined(__GNUC__) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) +// +// This is the only way we can avoid +// warning: non-standard suffix on floating constant [-Wpedantic] +// when building with -Wall -pedantic. Neither __extension__ +// nor #pragma diagnostic ignored work :( +// +#pragma GCC system_header +#endif + namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { namespace ccmath { namespace detail { -template -constexpr auto log_impl(T x) -> T +// LCOV_EXCL_START +template +constexpr auto exp_impl(Real x) noexcept -> Real +{ + constexpr int + my_digits_10 + { + ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits10 + }; + + constexpr int + loop_count + { + my_digits_10 < 8 ? 7 + : my_digits_10 < 16 ? 15 + : my_digits_10 < 20 ? 19 + : 33 + }; + + // Scale the argument with a single factor of 2. + // Then square the result upon return. + x /= 2; + + // Perform a simple Taylor series of the exponent function. + Real term { x }; + Real sum { Real { 1 } + term }; + + for (int loop_index { INT8_C(2) }; loop_index < loop_count; ++loop_index) + { + term *= x; + term /= static_cast(loop_index); + sum += term; + } + + // Scale the result. + return sum * sum; +} + +template +constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54), Real>::type { - // Default to the regular log function. - using std::log; + // PadeApproximant[Log[x], {x, 1, {8, 8}}] + // FullSimplify[%] + + const Real + top + { + ((static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(761.0L) + x * (static_cast(28544.0L) + x * (static_cast(209305.0L) + x * (static_cast(423680.0L) + x * (static_cast(209305.0L) + x * (static_cast(28544.0L) + static_cast(761.0L) * x))))))) + }; + + const Real + bot + { + (static_cast(140.0L) * (static_cast(1.0L) + x * (static_cast(64.0L) + x * (static_cast(784.0L) + x * (static_cast(3136.0L) + x * (static_cast(4900.0L) + x * (static_cast(3136.0L) + x * (static_cast(784.0L) + x * (static_cast(64.0L) + x))))))))) + }; - return log(x); + return top / bot; } +template +constexpr auto log_impl_pade(Real x) noexcept -> typename std::enable_if<(!(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits < 54)), Real>::type +{ + // PadeApproximant[Log[x], {x, 1, {16, 16}}] + // FullSimplify[%] + + const Real + top + { + (static_cast(17.0L) * (static_cast(-1.0L) + x) * (static_cast(1.0L) + x) * (static_cast(143327.0L) + x * (static_cast(25160192.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(1923749922816.0L) + x * (static_cast(1446475477311.0L) + x * (static_cast(613705186816.0L) + x * (static_cast(144291009727.0L) + x * (static_cast(17931092992.0L) + x * (static_cast(1069458527.0L) + x * (static_cast(25160192.0L) + static_cast(143327.0L) * x))))))))))))))) + }; + + const Real + bot + { + (static_cast(360360.0L) * (static_cast(1.0L) + x * (static_cast(256.0L) + x * (static_cast(14400.0L) + x * (static_cast(313600.0L) + x * (static_cast(3312400.0L) + x * (static_cast(19079424.0L) + x * (static_cast(64128064.0L) + x * (static_cast(130873600.0L) + x * (static_cast(165636900.0L) + x * (static_cast(130873600.0L) + x * (static_cast(64128064.0L) + x * (static_cast(19079424.0L) + x * (static_cast(3312400.0L) + x * (static_cast(313600.0L) + x * (static_cast(14400.0L) + x * (static_cast(256.0L) + x))))))))))))))))) + }; + + return top / bot; +} + +// N[Log[2], 101] +// 0.69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641868754 + +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 24), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 53), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 64), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +#if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068Q); } +#else +template constexpr auto constant_ln_two() noexcept -> typename ::std::enable_if<(::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::numeric_limits::digits == 113), FloatingPointType>::type { return static_cast(0.69314718055994530941723212145817656807550013436025525412068L); } +#endif + +template +constexpr auto log_impl(Real x) noexcept -> Real +{ + int n2 { }; + + Real x2 { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::detail::frexp_impl(x, &n2) }; + + if (x2 > static_cast(0.875L)) + { + x2 /= 2; + + ++n2; + } + + Real s { log_impl_pade(x2) }; + + const Real E { exp_impl(s) }; + + // Do one single step of Newton-Raphson iteration. + s = s + ((x2 - E) / E); + + Real xn2 { static_cast(n2) * constant_ln_two() }; + + s += xn2; + + return s; +} +// LCOV_EXCL_STOP + } // namespace detail template constexpr auto log(Real x) -> Real { - return cpp_df_qf_detail::ccmath::detail::log_impl(x); + if (BOOST_MP_IS_CONST_EVALUATED(x)) + { + return detail::log_impl(x); // LCOV_EXCL_LINE + } + else + { + using std::log; + + return log(x); + } } } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp index 7c9aac5fb..3906b9892 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp @@ -52,12 +52,6 @@ constexpr auto sqrt(Real x) noexcept -> Real } } -template -constexpr auto sqrt_constexpr(Real x) -> Real -{ - return detail::sqrt_impl(x); -} - } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath #endif // BOOST_MP_CPP_DF_QF_DETAIL_CCMATH_SQRT_2023_01_07_HPP diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 2c99be49b..d58e5203c 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -943,26 +943,27 @@ class cpp_double_fp_backend // Use the non-normalized sum of two maximum values, where the lower // value is "shifted" right in the sense of floating-point ldexp. - return cpp_double_fp_backend + return + cpp_double_fp_backend ( arithmetic::two_hilo_sum ( float_type - { - (cpp_df_qf_detail::ccmath::numeric_limits::max)() - * ( - static_cast(1.0F) - - static_cast(1.5F) * cpp_df_qf_detail::ccmath::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) - ) - }, + ( + (cpp_df_qf_detail::ccmath::numeric_limits::max)() + * ( + static_cast(1.0F) + - static_cast(1.5F) * cpp_df_qf_detail::ccmath::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + ) + ), float_type - { - cpp_df_qf_detail::ccmath::ldexp - ( - (cpp_df_qf_detail::ccmath::numeric_limits::max)(), - -cpp_df_qf_detail::ccmath::numeric_limits::digits - ) - } + ( + cpp_df_qf_detail::ccmath::ldexp + ( + (cpp_df_qf_detail::ccmath::numeric_limits::max)(), + -cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + ) ) ); } @@ -972,7 +973,8 @@ class cpp_double_fp_backend // Use the non-normalized minimum value, where the lower value // is "shifted" left in the sense of floating-point ldexp. - return cpp_double_fp_backend + return + cpp_double_fp_backend ( float_type ( @@ -987,7 +989,8 @@ class cpp_double_fp_backend static constexpr auto my_value_eps() noexcept -> cpp_double_fp_backend { - return cpp_double_fp_backend + return + cpp_double_fp_backend ( float_type(cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits })) ); @@ -1005,12 +1008,40 @@ class cpp_double_fp_backend static constexpr auto my_value_logmax() -> cpp_double_fp_backend { - return float_type(cpp_df_qf_detail::ccmath::log(my_value_max().my_first())); + return + cpp_double_fp_backend + ( + cpp_df_qf_detail::ccmath::log + ( + float_type + ( + (cpp_df_qf_detail::ccmath::numeric_limits::max)() + * ( + static_cast(1.0F) + - static_cast(1.5F) * cpp_df_qf_detail::ccmath::sqrt(cpp_df_qf_detail::ccmath::numeric_limits::epsilon()) + ) + ) + ) + ); } static constexpr auto my_value_logmin() -> cpp_double_fp_backend { - return float_type(cpp_df_qf_detail::ccmath::log(my_value_min().my_first())); + return + cpp_double_fp_backend + ( + cpp_df_qf_detail::ccmath::log + ( + float_type + ( + cpp_df_qf_detail::ccmath::ldexp + ( + (cpp_df_qf_detail::ccmath::numeric_limits::min)(), + cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + ) + ) + ); } private: diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 83bb53487..e21dd540a 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -30,14 +30,17 @@ auto test_constexpr_ness() noexcept -> void constexpr local_float_type dd_s { sqrt(dd_a) }; constexpr local_float_type sqrt_hundred { sqrt(local_float_type(100)) }; + constexpr local_float_type log_hundred { log(local_float_type(100)) }; static_assert(dd_c > 5, "Error in constexpr multiplication"); static_assert(dd_s > 1, "Error in constexpr square root"); static_assert(sqrt_hundred == 10, "Error in constexpr square root"); + static_assert(log_hundred > local_float_type(4.605L), "Error in constexpr logarithm"); BOOST_CHECK(dd_c > 5); BOOST_CHECK(dd_s > 1); BOOST_CHECK(sqrt_hundred == 10); + BOOST_CHECK(log_hundred > local_float_type(4.605L)); } int main() From 4aa8952e8d855d91ab8503d174117280be771937 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 18:50:46 +0200 Subject: [PATCH 077/114] Disable test_round for double-fp on old GCC --- test/test_round.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/test/test_round.cpp b/test/test_round.cpp index c57bd4d8a..0f1c2453f 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -510,12 +510,20 @@ int main() test(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT + + // When using very old GCC, categorically disable this test for cpp_double_fp_backend. + // Do not attempt, at the moment, to track down the compiler's "internal failure". + + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else test(); test(); test(); #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif + #endif + #endif return boost::report_errors(); From d64f23f13b7dddca9854b2f5098554fa444e4b8a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 21:44:57 +0200 Subject: [PATCH 078/114] First pass double_fp single-limb optimizations --- include/boost/multiprecision/cpp_double_fp.hpp | 7 +++++-- performance/performance_test_df.cpp | 2 +- test/test_round.cpp | 8 ++++++++ 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index d58e5203c..905a0e043 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -298,6 +298,8 @@ class cpp_double_fp_backend int u_index { 1 }; + float_type p2_flt { cpp_df_qf_detail::pow2_maker::value(std::numeric_limits::digits) }; + while (u > static_cast(UINT8_C(0))) { u >>= static_cast(std::numeric_limits::digits); @@ -305,13 +307,14 @@ class cpp_double_fp_backend const float_type xhi { - static_cast(u & flt_mask) - * cpp_df_qf_detail::pow2_maker::value(std::numeric_limits::digits * u_index) + static_cast(u & flt_mask) * p2_flt }; eval_add(*this, cpp_double_fp_backend(xhi)); ++u_index; + + p2_flt *= 2; } } diff --git a/performance/performance_test_df.cpp b/performance/performance_test_df.cpp index 16a8b8712..2e3157a88 100644 --- a/performance/performance_test_df.cpp +++ b/performance/performance_test_df.cpp @@ -51,7 +51,7 @@ #include "performance_test_df.hpp" // cd /mnt/c/Users/ckorm/Documents/Ks/PC_Software/Test -// g++ -std=gnu++14 -Wall -Wextra -O3 -I/mnt/c/ChrisGitRepos/boost_gsoc2021/multiprecision/performance -I/mnt/c/ChrisGitRepos/boost_gsoc2021/multiprecision/include -I/mnt/c/boost/boost_1_87_0 ./test.cpp -lquadmath -o test +// g++ -std=gnu++14 -Wall -Wextra -O3 -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/performance -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/include -I/mnt/c/boost/boost_1_89_0 ./test.cpp -lquadmath -o test // // Keys in order are: diff --git a/test/test_round.cpp b/test/test_round.cpp index 0f1c2453f..cd941b1e2 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -60,9 +60,17 @@ #include #endif #ifdef TEST_CPP_DOUBLE_FLOAT + +// When using very old GCC, categorically disable this test for cpp_double_fp_backend. +// Do not attempt, at the moment, to track down the compiler's "internal failure". + +#if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) +#else #include #endif +#endif + #ifdef BOOST_MSVC #pragma warning(disable : 4127) #endif From 23a5aaa3fdb47334dfe5d12469d850c5322237a5 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 22:10:00 +0200 Subject: [PATCH 079/114] Repair silly typo but might need detail study --- .../boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp | 9 --------- include/boost/multiprecision/cpp_double_fp.hpp | 8 ++++---- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index a95f247e8..59c6f6c20 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -155,15 +155,6 @@ struct exact_arithmetic } }; -template -struct pow2_maker -{ - static constexpr auto value(const int power_value) noexcept -> ArithmeticType - { - return ((power_value == 0) ? ArithmeticType { 1 } : ArithmeticType { 2 } * pow2_maker::value(power_value - 1)); - } -}; - } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail #endif // BOOST_MP_CPP_DF_QF_DETAIL_2023_01_02_HPP diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 905a0e043..5bd4db5f3 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -296,9 +296,9 @@ class cpp_double_fp_backend data.second = static_cast(0.0F); data.first = static_cast(u & flt_mask); - int u_index { 1 }; + int n_index { 1 }; - float_type p2_flt { cpp_df_qf_detail::pow2_maker::value(std::numeric_limits::digits) }; + float_type p2_flt { cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, std::numeric_limits::digits) }; while (u > static_cast(UINT8_C(0))) { @@ -312,9 +312,9 @@ class cpp_double_fp_backend eval_add(*this, cpp_double_fp_backend(xhi)); - ++u_index; + ++n_index; - p2_flt *= 2; + p2_flt = cpp_df_qf_detail::ccmath::ldexp(p2_flt, n_index); } } From 554bb279fbf247e297d681c19585dd5f70d339a3 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 1 Sep 2025 22:20:29 +0200 Subject: [PATCH 080/114] Correct yet another silly typo (or hope to) --- include/boost/multiprecision/cpp_double_fp.hpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 5bd4db5f3..78f22b514 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -296,8 +296,6 @@ class cpp_double_fp_backend data.second = static_cast(0.0F); data.first = static_cast(u & flt_mask); - int n_index { 1 }; - float_type p2_flt { cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, std::numeric_limits::digits) }; while (u > static_cast(UINT8_C(0))) @@ -312,9 +310,7 @@ class cpp_double_fp_backend eval_add(*this, cpp_double_fp_backend(xhi)); - ++n_index; - - p2_flt = cpp_df_qf_detail::ccmath::ldexp(p2_flt, n_index); + p2_flt = cpp_df_qf_detail::ccmath::ldexp(p2_flt, std::numeric_limits::digits); } } From c46c3bf0a19923f6e5b72cfd9c318e20a88028d9 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 2 Sep 2025 20:03:00 +0200 Subject: [PATCH 081/114] Speed up construction from ulonglong --- .../boost/multiprecision/cpp_double_fp.hpp | 90 +++++++++++++------ test/test_arithmetic_df.cpp | 4 +- 2 files changed, 65 insertions(+), 29 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 78f22b514..975e2f9cf 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -281,36 +281,56 @@ class cpp_double_fp_backend using local_unsigned_integral_type = UnsignedIntegralType; constexpr local_unsigned_integral_type - flt_mask + limb_mask { - static_cast - ( + local_unsigned_integral_type { local_unsigned_integral_type { 1 } << static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits) } + - local_unsigned_integral_type { 1 } + }; + + if (u <= limb_mask) + { + data = + { + static_cast(u), + static_cast(0.0F) + }; + } + else + { + constexpr local_unsigned_integral_type + flt_mask + { static_cast ( - static_cast(UINT8_C(1)) << static_cast(std::numeric_limits::digits) + static_cast + ( + static_cast(UINT8_C(1)) << static_cast(std::numeric_limits::digits) + ) + - static_cast(UINT8_C(1)) ) - - static_cast(UINT8_C(1)) - ) - }; + }; - data.second = static_cast(0.0F); - data.first = static_cast(u & flt_mask); + data.second = static_cast(0.0F); + data.first = static_cast(u & flt_mask); - float_type p2_flt { cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, std::numeric_limits::digits) }; + constexpr float_type p2_factor_digits { cpp_df_qf_detail::ccmath::ldexp(static_cast(1.0F), std::numeric_limits::digits) }; - while (u > static_cast(UINT8_C(0))) - { - u >>= static_cast(std::numeric_limits::digits); + float_type p2_factor { p2_factor_digits }; - const float_type - xhi - { - static_cast(u & flt_mask) * p2_flt - }; + while (u > static_cast(UINT8_C(0))) + { + u >>= static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits); + + const float_type + xhi + { + static_cast(u & flt_mask) * p2_factor + }; - eval_add(*this, cpp_double_fp_backend(xhi)); + add_unchecked_limb(xhi); - p2_flt = cpp_df_qf_detail::ccmath::ldexp(p2_flt, std::numeric_limits::digits); + p2_factor *= p2_factor_digits; + } } } @@ -526,13 +546,7 @@ class cpp_double_fp_backend } } - const rep_type thi_tlo { arithmetic::two_sum(data.second, v.data.second) }; - - data = arithmetic::two_sum(data.first, v.data.first); - - data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); - - data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); + add_unchecked(v); return *this; } @@ -1053,6 +1067,28 @@ class cpp_double_fp_backend auto rd_string(const char* pstr) -> bool; + constexpr auto add_unchecked(const cpp_double_fp_backend& v) -> void + { + const rep_type thi_tlo { arithmetic::two_sum(data.second, v.data.second) }; + + data = arithmetic::two_sum(data.first, v.data.first); + + data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); + + data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); + } + + constexpr auto add_unchecked_limb(const float_type v_first) -> void + { + const rep_type thi_tlo { data.second, static_cast(0.0F) }; + + data = arithmetic::two_sum(data.first, v_first); + + data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); + + data = arithmetic::two_hilo_sum(data.first, data.second); + } + constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void { // The multiplication algorithm has been taken from Victor Shoup, diff --git a/test/test_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index e21dd540a..add807815 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -20,9 +20,9 @@ auto test_constexpr_ness() noexcept -> void constexpr local_float_type one { 1 }; - static_assert(static_cast(one) == 1, "Error: constexpr local_float_type construction failed"); + static_assert(one == 1, "Error: constexpr local_float_type construction failed"); - BOOST_CHECK(static_cast(one) == 1); + BOOST_CHECK(one == 1); constexpr local_float_type dd_a { 1.23 }; constexpr local_float_type dd_b { 4.56 }; From c05678649d683904a91c5c519178c795ae923e2b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 2 Sep 2025 20:26:32 +0200 Subject: [PATCH 082/114] Correct a few potential typos --- include/boost/multiprecision/cpp_double_fp.hpp | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 975e2f9cf..d3455dcf1 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -313,9 +313,17 @@ class cpp_double_fp_backend data.second = static_cast(0.0F); data.first = static_cast(u & flt_mask); - constexpr float_type p2_factor_digits { cpp_df_qf_detail::ccmath::ldexp(static_cast(1.0F), std::numeric_limits::digits) }; + constexpr float_type + p2_factor_digits + ( + cpp_df_qf_detail::ccmath::ldexp + ( + static_cast(1.0F), + cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + ); - float_type p2_factor { p2_factor_digits }; + float_type p2_factor(p2_factor_digits); while (u > static_cast(UINT8_C(0))) { @@ -324,7 +332,7 @@ class cpp_double_fp_backend const float_type xhi { - static_cast(u & flt_mask) * p2_factor + static_cast(static_cast(u & flt_mask) * p2_factor) }; add_unchecked_limb(xhi); @@ -1080,11 +1088,11 @@ class cpp_double_fp_backend constexpr auto add_unchecked_limb(const float_type v_first) -> void { - const rep_type thi_tlo { data.second, static_cast(0.0F) }; + const float_type thi { data.second }; data = arithmetic::two_sum(data.first, v_first); - data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); + data = arithmetic::two_hilo_sum(data.first, data.second + thi); data = arithmetic::two_hilo_sum(data.first, data.second); } From 8f536de8087e03415922beb37806e17df5741c4f Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Tue, 2 Sep 2025 20:32:02 +0200 Subject: [PATCH 083/114] Repair even more subtle namespace typos --- include/boost/multiprecision/cpp_double_fp.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index d3455dcf1..c56e5f857 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -184,9 +184,9 @@ class cpp_double_fp_backend cpp_df_qf_detail::is_floating_point::value && bool { - ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 24) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) - || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 53) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) - || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 64) && std::numeric_limits::is_specialized && std::numeric_limits::is_iec559) + ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 24) && cpp_df_qf_detail::ccmath::numeric_limits::is_specialized && cpp_df_qf_detail::ccmath::numeric_limits::is_iec559) + || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 53) && cpp_df_qf_detail::ccmath::numeric_limits::is_specialized && cpp_df_qf_detail::ccmath::numeric_limits::is_iec559) + || ((cpp_df_qf_detail::ccmath::numeric_limits::digits == 64) && cpp_df_qf_detail::ccmath::numeric_limits::is_specialized && cpp_df_qf_detail::ccmath::numeric_limits::is_iec559) || (cpp_df_qf_detail::ccmath::numeric_limits::digits == 113) }, "Error: float_type does not fulfill the backend requirements of cpp_double_fp_backend" ); @@ -304,7 +304,7 @@ class cpp_double_fp_backend ( static_cast ( - static_cast(UINT8_C(1)) << static_cast(std::numeric_limits::digits) + static_cast(UINT8_C(1)) << static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits) ) - static_cast(UINT8_C(1)) ) From 6330e2347896c7ad87cd93b9b5c63c8d718e9c04 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Wed, 3 Sep 2025 19:37:37 +0200 Subject: [PATCH 084/114] Further simplify constexpr-ness --- .../cpp_df_qf/cpp_df_qf_detail.hpp | 17 +++++ .../boost/multiprecision/cpp_double_fp.hpp | 64 ++++--------------- test/test_round.cpp | 6 -- 3 files changed, 29 insertions(+), 58 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index 59c6f6c20..23742463e 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -32,6 +32,23 @@ namespace boost { namespace multiprecision { namespace backends { namespace cpp_df_qf_detail { +template +constexpr auto float_mask() noexcept -> UnsignedIntegralType +{ + using local_unsigned_integral_type = UnsignedIntegralType; + using local_float_type = FloatType; + + static_assert(static_cast(sizeof(UnsignedIntegralType) * 8u) > static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits), + "Error: this function is intended for unsigned integral type wider than the float type."); + + return + { + local_unsigned_integral_type { local_unsigned_integral_type { 1 } << static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits) } + - local_unsigned_integral_type { 1 } + }; +} + template struct pair { diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index c56e5f857..d2c903486 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -277,67 +277,27 @@ class cpp_double_fp_backend && boost::multiprecision::detail::is_unsigned::value && (static_cast(sizeof(UnsignedIntegralType) * 8u) > cpp_df_qf_detail::ccmath::numeric_limits::digits))>::type const* = nullptr> constexpr cpp_double_fp_backend(UnsignedIntegralType u) + : data(static_cast(u & cpp_df_qf_detail::float_mask()), + static_cast(0.0F)) { using local_unsigned_integral_type = UnsignedIntegralType; - constexpr local_unsigned_integral_type - limb_mask - { - local_unsigned_integral_type { local_unsigned_integral_type { 1 } << static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits) } - - local_unsigned_integral_type { 1 } - }; - - if (u <= limb_mask) - { - data = - { - static_cast(u), - static_cast(0.0F) - }; - } - else + if (u > cpp_df_qf_detail::float_mask()) { - constexpr local_unsigned_integral_type - flt_mask + local_unsigned_integral_type + local_flt_mask { - static_cast - ( - static_cast - ( - static_cast(UINT8_C(1)) << static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits) - ) - - static_cast(UINT8_C(1)) - ) + cpp_df_qf_detail::float_mask() }; - data.second = static_cast(0.0F); - data.first = static_cast(u & flt_mask); - - constexpr float_type - p2_factor_digits - ( - cpp_df_qf_detail::ccmath::ldexp - ( - static_cast(1.0F), - cpp_df_qf_detail::ccmath::numeric_limits::digits - ) - ); - - float_type p2_factor(p2_factor_digits); - - while (u > static_cast(UINT8_C(0))) + for (int index_mask_lsb = cpp_df_qf_detail::ccmath::numeric_limits::digits; + (index_mask_lsb < static_cast(sizeof(local_unsigned_integral_type) * 8u)) + && (local_flt_mask != local_unsigned_integral_type { UINT8_C(0) }); + index_mask_lsb += cpp_df_qf_detail::ccmath::numeric_limits::digits) { - u >>= static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits); - - const float_type - xhi - { - static_cast(static_cast(u & flt_mask) * p2_factor) - }; - - add_unchecked_limb(xhi); + local_flt_mask <<= static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits); - p2_factor *= p2_factor_digits; + add_unchecked_limb(static_cast(u & local_flt_mask)); } } } diff --git a/test/test_round.cpp b/test/test_round.cpp index cd941b1e2..89a69d822 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -519,18 +519,12 @@ int main() #endif #ifdef TEST_CPP_DOUBLE_FLOAT - // When using very old GCC, categorically disable this test for cpp_double_fp_backend. - // Do not attempt, at the moment, to track down the compiler's "internal failure". - - #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) - #else test(); test(); test(); #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif - #endif #endif From 793f9bb9a064fc866080344ea44a0c12ef02a181 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Wed, 3 Sep 2025 20:17:25 +0200 Subject: [PATCH 085/114] Try repair some trivial typos --- .../boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp | 2 +- test/test_round.cpp | 8 -------- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index 23742463e..06e1e87a1 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -39,7 +39,7 @@ constexpr auto float_mask() noexcept -> UnsignedIntegralType using local_unsigned_integral_type = UnsignedIntegralType; using local_float_type = FloatType; - static_assert(static_cast(sizeof(UnsignedIntegralType) * 8u) > static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits), + static_assert(static_cast(sizeof(local_unsigned_integral_type) * 8u) > static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits), "Error: this function is intended for unsigned integral type wider than the float type."); return diff --git a/test/test_round.cpp b/test/test_round.cpp index 89a69d822..ba19ef5dc 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -60,17 +60,9 @@ #include #endif #ifdef TEST_CPP_DOUBLE_FLOAT - -// When using very old GCC, categorically disable this test for cpp_double_fp_backend. -// Do not attempt, at the moment, to track down the compiler's "internal failure". - -#if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) -#else #include #endif -#endif - #ifdef BOOST_MSVC #pragma warning(disable : 4127) #endif From cbcf51c54a223463edc2769c332d10df31332339 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Wed, 3 Sep 2025 20:46:40 +0200 Subject: [PATCH 086/114] Disable test_round for old GCC --- test/test_round.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/test_round.cpp b/test/test_round.cpp index ba19ef5dc..837d672bc 100644 --- a/test/test_round.cpp +++ b/test/test_round.cpp @@ -60,8 +60,11 @@ #include #endif #ifdef TEST_CPP_DOUBLE_FLOAT +#if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) +#else #include #endif +#endif #ifdef BOOST_MSVC #pragma warning(disable : 4127) @@ -511,12 +514,15 @@ int main() #endif #ifdef TEST_CPP_DOUBLE_FLOAT + #if (defined(BOOST_GCC) && !defined(BOOST_CLANG) && (BOOST_GCC < 80000)) + #else test(); test(); test(); #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) test(); #endif + #endif #endif From 732b19bd2f75a0e966dc8032740604808f4ee6fe Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 11:49:57 +0200 Subject: [PATCH 087/114] Try handle more double_fp findings --- .../cpp_df_qf/cpp_df_qf_detail.hpp | 15 ++-- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 2 +- .../boost/multiprecision/cpp_double_fp.hpp | 85 +++++++++++-------- test/test_various_edges_more.cpp | 27 +++++- 4 files changed, 85 insertions(+), 44 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index 06e1e87a1..51095a5aa 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -56,15 +56,20 @@ struct pair using float_type = FloatingPointTypeA; + #if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 202002L)) float_type first; float_type second; - - constexpr pair() : first { }, second { } { }; - constexpr pair(float_type a, float_type b) : first { a }, second { b } { } - constexpr pair(const pair& other) : first { other.first }, second { other.second } { } + #else + float_type first { }; + float_type second { }; + #endif + + constexpr pair() noexcept { } + constexpr pair(float_type a, float_type b) noexcept : first { a }, second { b } { } + constexpr pair(const pair& other) noexcept : first { other.first }, second { other.second } { } constexpr pair(pair&& other) noexcept : first { other.first }, second { other.second } { } - constexpr auto operator=(const pair& other) -> pair& + constexpr auto operator=(const pair& other) noexcept -> pair& { if (this != &other) { diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index d1ce84045..368293a5c 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -14,7 +14,7 @@ #include #include -#if (defined(__GNUC__) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) +#if (defined(BOOST_GCC) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) // // This is the only way we can avoid // warning: non-standard suffix on floating constant [-Wpedantic] diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index d2c903486..e66f144bb 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -139,7 +139,7 @@ constexpr auto eval_convert_to(OtherFloatingPointType* result, const cpp_double_ // TBD: constexpr on hash_value? template -auto hash_value(const cpp_double_fp_backend& a) -> ::std::size_t; +constexpr auto hash_value(const cpp_double_fp_backend& a) -> ::std::size_t; template constexpr auto fabs(const cpp_double_fp_backend& a) -> cpp_double_fp_backend; @@ -385,38 +385,12 @@ class cpp_double_fp_backend return *this; } - auto hash() const -> ::std::size_t + constexpr auto hash() const -> ::std::size_t { - // Hash the raw values of the data field with direct-memory access. - // Use 16-bit (2 byte) chunks as the data size when hashing. - - static_assert( ( sizeof(data.first) == sizeof(data.second)) - && ( sizeof(float_type) >= sizeof(std::uint16_t)) - && ((sizeof(float_type) % sizeof(std::uint16_t)) == std::size_t { UINT8_C(0) }), - "Error: float_type size is inappropriate for hashing routine"); - - auto hash_one - { - [](std::size_t& res, const float_type& val) - { - const std::uint16_t* first { reinterpret_cast(&val) }; - const std::uint16_t* last { first + std::size_t { sizeof(float_type) / sizeof(std::uint16_t) } }; - - while (first != last) - { - boost::multiprecision::detail::hash_combine(res, *first); - - ++first; - } - - return res; - } - }; - std::size_t result { UINT8_C(0) }; - static_cast(hash_one(result, data.first)); - static_cast(hash_one(result, data.second)); + boost::multiprecision::detail::hash_combine(result, data.first); + boost::multiprecision::detail::hash_combine(result, data.second); return result; } @@ -574,6 +548,21 @@ class cpp_double_fp_backend data = arithmetic::two_diff(data.first, v.data.first); + if (cpp_df_qf_detail::ccmath::isinf(data.first)) + { + // Handle overflow. + const bool b_neg { (data.first < float_type { 0.0F }) }; + + *this = cpp_double_fp_backend::my_value_inf(); + + if (b_neg) + { + negate(); + } + + return *this; + } + data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); @@ -885,7 +874,7 @@ class cpp_double_fp_backend } } - auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string + constexpr auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string { if (number_of_digits == 0) { @@ -1033,7 +1022,7 @@ class cpp_double_fp_backend using cpp_bin_float_read_write_type = boost::multiprecision::number; - auto rd_string(const char* pstr) -> bool; + constexpr auto rd_string(const char* pstr) -> bool; constexpr auto add_unchecked(const cpp_double_fp_backend& v) -> void { @@ -1041,6 +1030,21 @@ class cpp_double_fp_backend data = arithmetic::two_sum(data.first, v.data.first); + if (cpp_df_qf_detail::ccmath::isinf(data.first)) + { + // Handle overflow. + const bool b_neg { (data.first < float_type { 0.0F }) }; + + *this = cpp_double_fp_backend::my_value_inf(); + + if (b_neg) + { + negate(); + } + + return; + } + data = arithmetic::two_hilo_sum(data.first, data.second + thi_tlo.first); data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); @@ -1052,6 +1056,19 @@ class cpp_double_fp_backend data = arithmetic::two_sum(data.first, v_first); + if (cpp_df_qf_detail::ccmath::isinf(data.first)) + { + // Handle overflow. + *this = cpp_double_fp_backend::my_value_inf(); + + if (data.first) + { + negate(); + } + + return; + } + data = arithmetic::two_hilo_sum(data.first, data.second + thi); data = arithmetic::two_hilo_sum(data.first, data.second); @@ -1156,7 +1173,7 @@ class cpp_double_fp_backend }; template -auto cpp_double_fp_backend::rd_string(const char* pstr) -> bool +constexpr auto cpp_double_fp_backend::rd_string(const char* pstr) -> bool { cpp_bin_float_read_write_type f_bin { pstr }; @@ -2458,7 +2475,7 @@ constexpr auto eval_convert_to(OtherFloatingPointType* result, const cpp_double_ } template -auto hash_value(const cpp_double_fp_backend& a) -> ::std::size_t +constexpr auto hash_value(const cpp_double_fp_backend& a) -> ::std::size_t { return a.hash(); } diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index b8163cc3c..26e5e9f23 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -499,8 +499,6 @@ namespace local result_is_ok = (result_unf_is_ok && result_is_ok); } - // TBD: See open issues for reminder to get this working in cpp_double_fp_backend. - BOOST_IF_CONSTEXPR(!::has_poor_exp_range_or_precision_support::value) { using std::ldexp; @@ -524,8 +522,6 @@ namespace local result_is_ok = (result_ovf_is_ok && result_is_ok); } - // TBD: See open issues for reminder to get this working in cpp_double_fp_backend. - BOOST_IF_CONSTEXPR(!::has_poor_exp_range_or_precision_support::value) { using std::ldexp; @@ -549,6 +545,29 @@ namespace local result_is_ok = (result_ovf_is_ok && result_is_ok); } + { + using std::ldexp; + + float_type flt_near_lowest { -ldexp((std::numeric_limits::max)(), -1) }; + + const float_type neg_flt_less_near_max { -ldexp((std::numeric_limits::max)(), -4) }; + + unsigned index { }; + + while((index < max_index) && (!(boost::multiprecision::isinf)(flt_near_lowest))) + { + flt_near_lowest += (neg_flt_less_near_max * dis(gen)); + + ++index; + } + + const bool result_ovf_is_ok { ((index > 1U) && (index < max_index)) && signbit(flt_near_lowest) }; + + BOOST_TEST(result_ovf_is_ok); + + result_is_ok = (result_ovf_is_ok && result_is_ok); + } + for(int n_loop = static_cast(INT8_C(-16)); n_loop < static_cast(INT8_C(-8)); ++n_loop) { using std::ldexp; From cc0568302f50361a84325f9fa70d3fbfb1d04547 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 12:02:41 +0200 Subject: [PATCH 088/114] Default-constructed values are zero --- .../boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index 51095a5aa..b2f60d693 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -56,15 +56,12 @@ struct pair using float_type = FloatingPointTypeA; - #if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 202002L)) float_type first; float_type second; - #else - float_type first { }; - float_type second { }; - #endif - constexpr pair() noexcept { } + // Default-constructed cpp_double_fp_backend values are zero. + constexpr pair() noexcept : first { }, second { } { } + constexpr pair(float_type a, float_type b) noexcept : first { a }, second { b } { } constexpr pair(const pair& other) noexcept : first { other.first }, second { other.second } { } constexpr pair(pair&& other) noexcept : first { other.first }, second { other.second } { } From a5c96658f9407fac9f942f569575c1d9b631eace Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 12:55:28 +0200 Subject: [PATCH 089/114] Handle matters of syntax --- .../boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp | 8 +++----- include/boost/multiprecision/cpp_double_fp.hpp | 8 +++++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp index b2f60d693..4adfc77c4 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright 2021 Fahad Syed. +// Copyright 2021 - 2025 Fahad Syed. // Copyright 2021 - 2025 Christopher Kormanyos. -// Copyright 2021 Janek Kozicki. +// Copyright 2021 - 2025 Janek Kozicki. // 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) @@ -13,7 +13,6 @@ #include #if defined(BOOST_HAS_FLOAT128) -#if defined(__has_include) #if __has_include() #include @@ -23,7 +22,6 @@ #endif #endif // __has_include() -#endif // defined(__has_include) #endif // defined(BOOST_HAS_FLOAT128) #include @@ -112,7 +110,7 @@ struct split_maker }; static_assert(n_shl < std::numeric_limits::digits, - "Error: Left-shift amount for split does not fin in std::uint64_t"); + "Error: Left-shift amount for split does not fit in std::uint64_t"); static constexpr float_type value diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index e66f144bb..23c7dfe3d 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -37,7 +37,7 @@ #include #include -#if (defined(__clang__) && (__clang_major__ <= 9)) +#if (defined(BOOST_CLANG) && defined(BOOST_CLANG_VERSION) && (BOOST_CLANG_VERSION <= 90000)) #define BOOST_MP_DF_QF_NUM_LIMITS_CLASS_TYPE struct #else #define BOOST_MP_DF_QF_NUM_LIMITS_CLASS_TYPE class @@ -137,7 +137,6 @@ template constexpr auto eval_convert_to(OtherFloatingPointType* result, const cpp_double_fp_backend& backend) -> typename ::std::enable_if::value>::type; -// TBD: constexpr on hash_value? template constexpr auto hash_value(const cpp_double_fp_backend& a) -> ::std::size_t; @@ -874,7 +873,10 @@ class cpp_double_fp_backend } } - constexpr auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string + #if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 202002L)) + constexpr + #endif + auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string { if (number_of_digits == 0) { From 3f6953cc7fa7b7bde4c08d2198323ec642d5d8a6 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 15:13:58 +0200 Subject: [PATCH 090/114] Patch hash for boost::float128_type limb --- include/boost/multiprecision/cpp_double_fp.hpp | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 23c7dfe3d..578e32e64 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -388,8 +388,21 @@ class cpp_double_fp_backend { std::size_t result { UINT8_C(0) }; - boost::multiprecision::detail::hash_combine(result, data.first); - boost::multiprecision::detail::hash_combine(result, data.second); + int n_first { }; + int n_second { }; + + #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) + using local_float_type = typename std::conditional<::std::is_same::value, + long double, + float_type>::type; + #else + using local_float_type = float_type; + #endif + + boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.first, &n_first))); + boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.second, &n_second))); + boost::multiprecision::detail::hash_combine(result, n_first); + boost::multiprecision::detail::hash_combine(result, n_second); return result; } From 51941b4d3e4a14bbeb5c26f89891892ef23c246d Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 18:14:32 +0200 Subject: [PATCH 091/114] Remove all constexpr constraints str() method --- include/boost/multiprecision/cpp_double_fp.hpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 578e32e64..61bac1049 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -886,9 +886,10 @@ class cpp_double_fp_backend } } - #if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 202002L)) - constexpr - #endif + // TBD: Exactly what compilers/language-standards are needed to make this constexpr? + // TBD: It odes not really become constexpr until we stop using an intermediate + // cpp_bin_float anyway. But I will leave this comment for future library evolution. + auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string { if (number_of_digits == 0) From f54b239049d9dc697b87be2f523ea263fcd655e7 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Thu, 4 Sep 2025 21:03:14 +0200 Subject: [PATCH 092/114] Remove very hard-to-reach lines for later --- include/boost/multiprecision/cpp_double_fp.hpp | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 61bac1049..5700be2af 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1072,19 +1072,6 @@ class cpp_double_fp_backend data = arithmetic::two_sum(data.first, v_first); - if (cpp_df_qf_detail::ccmath::isinf(data.first)) - { - // Handle overflow. - *this = cpp_double_fp_backend::my_value_inf(); - - if (data.first) - { - negate(); - } - - return; - } - data = arithmetic::two_hilo_sum(data.first, data.second + thi); data = arithmetic::two_hilo_sum(data.first, data.second); From 5017931c87e2865e91df40b9392aaebd41d8d0d5 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 6 Sep 2025 10:22:05 +0200 Subject: [PATCH 093/114] Handle Git issue 734 in docs and code --- doc/reference_backend_requirements.qbk | 2 +- doc/reference_number.qbk | 8 +-- .../boost/multiprecision/cpp_dec_float.hpp | 2 +- .../boost/multiprecision/cpp_double_fp.hpp | 5 -- test/Jamfile.v2 | 1 + test/git_issue_734.cpp | 68 +++++++++++++++++++ 6 files changed, 75 insertions(+), 11 deletions(-) create mode 100644 test/git_issue_734.cpp diff --git a/doc/reference_backend_requirements.qbk b/doc/reference_backend_requirements.qbk index 2d94a25ef..2047baa27 100644 --- a/doc/reference_backend_requirements.qbk +++ b/doc/reference_backend_requirements.qbk @@ -45,7 +45,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpreted as a valid number.]] [[`b.swap(b)`][`void`][Swaps the contents of its arguments.][`noexcept`]] [[`cb.str(ss, ff)`][`std::string`][Returns the string representation of `b` with `ss` digits and formatted according to the flags set in `ff`. - If `ss` is zero, then returns as many digits as are required to reconstruct the original value.][[space]]] + If `ss` is zero and neither of `std::ios::fixed` and `std::ios::scientific` is set in the float-field, then returns as many digits as are required to reconstruct the original value.][[space]]] [[`b.negate()`][`void`][Negates `b`.][[space]]] [[`cb.compare(cb2)`][`int`][Compares `cb` and `cb2`, returns a value less than zero if `cb < cb2`, a value greater than zero if `cb > cb2` and zero if `cb == cb2`.][`noexcept`]] diff --git a/doc/reference_number.qbk b/doc/reference_number.qbk index c8e707b11..b6360d3e1 100644 --- a/doc/reference_number.qbk +++ b/doc/reference_number.qbk @@ -58,7 +58,7 @@ bool is_zero()const; int sign()const; // string conversion: - std::string str()const; + std::string str(std::streamsize digits = 0, std::ios_base::fmtflags f = std::ios_base::fmtflags(0))const; // Generic conversion mechanism template T convert_to()const; @@ -416,10 +416,10 @@ Returns `true` is `*this` is zero, otherwise `false`. Returns a value less than zero if `*this` is negative, a value greater than zero if `*this` is positive, and zero if `*this` is zero. - std::string str(unsigned precision, bool scientific = true)const; + std::string str(std::streamsize digits = 0, std::ios_base::fmtflags f = std::ios_base::fmtflags(0))const; -Returns the number formatted as a string, with at least /precision/ digits, and in scientific format -if /scientific/ is true. +Returns the number formatted as a string, with at least /precision/ digits, and adhering to the format +flags in /f/ if provided. template T convert_to()const; diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index e9ae39f58..d4c8cad2a 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1928,7 +1928,7 @@ std::string cpp_dec_float::str(std::intmax_t if (f & std::ios_base::fixed) { - number_of_digits += my_exp + 1; + number_of_digits = (std::max)(static_cast(number_of_digits + my_exp + 1), std::intmax_t { INT8_C(0) }); } else if (f & std::ios_base::scientific) ++number_of_digits; diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 5700be2af..f8bbd9071 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -892,11 +892,6 @@ class cpp_double_fp_backend auto str(std::streamsize number_of_digits, const std::ios::fmtflags format_flags) const -> std::string { - if (number_of_digits == 0) - { - number_of_digits = cpp_double_fp_backend::my_digits10; - } - // Use cpp_bin_float when writing to string. This is similar // to the use of cpp_bin_float when reading from string. diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 9af721754..21cfc547f 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -1276,6 +1276,7 @@ test-suite misc : [ run git_issue_626.cpp ] [ run git_issue_636.cpp : : : [ check-target-builds ../config//has_float128 : quadmath : no ] ] [ run git_issue_652.cpp ] + [ run git_issue_734.cpp ] [ compile git_issue_98.cpp : [ check-target-builds ../config//has_float128 : TEST_FLOAT128 quadmath : ] [ check-target-builds ../config//has_gmp : TEST_GMP gmp : ] diff --git a/test/git_issue_734.cpp b/test/git_issue_734.cpp new file mode 100644 index 000000000..10fc2ce7b --- /dev/null +++ b/test/git_issue_734.cpp @@ -0,0 +1,68 @@ +// Copyright 2025 Christopher Kormanyos +// Distributed under the Boost Software License, Version 1.0. +// https://www.boost.org/LICENSE_1_0.txt + +#include +#include +#include +#include + +#include +#include +#include + +namespace local { + +template +auto my_stringify_via_top_level_number(const std::streamsize strm_size) -> std::string +{ + using float_type = boost::multiprecision::number; + + float_type x("0.0000000000000000222222222222222"); + + std::stringstream strm { }; + + strm << std::setprecision(strm_size) << std::fixed; + strm << x; + + return strm.str(); +} + +template +auto my_stringify_via_str_and_backend_str(const std::streamsize strm_size) -> std::string +{ + using float_type = boost::multiprecision::number; + + float_type x("0.0000000000000000222222222222222"); + + std::stringstream strm { }; + + strm << std::setprecision(strm_size) << std::fixed; + + return x.str(strm_size, strm.flags()); +} + +template +auto test() -> void +{ + BOOST_TEST(my_stringify_via_top_level_number(0) == "0"); + BOOST_TEST(my_stringify_via_top_level_number(8) == "0.00000000"); + BOOST_TEST(my_stringify_via_top_level_number(12) == "0.000000000000"); + BOOST_TEST(my_stringify_via_top_level_number(31) == "0.0000000000000000222222222222222"); + + BOOST_TEST(my_stringify_via_str_and_backend_str(0) == "0"); + BOOST_TEST(my_stringify_via_str_and_backend_str(8) == "0.00000000"); + BOOST_TEST(my_stringify_via_str_and_backend_str(12) == "0.000000000000"); + BOOST_TEST(my_stringify_via_str_and_backend_str(31) == "0.0000000000000000222222222222222"); +} + +} // namespace local + +auto main() -> int +{ + local::test>(); + local::test>(); + local::test>(); + + return boost::report_errors(); +} From 2f07bf5e26a5a0dcb14da3fb70ef83ad2d3c5000 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 6 Sep 2025 12:33:44 +0200 Subject: [PATCH 094/114] Revert misguided change in cpp_dec_float --- include/boost/multiprecision/cpp_dec_float.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index d4c8cad2a..e9ae39f58 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1928,7 +1928,7 @@ std::string cpp_dec_float::str(std::intmax_t if (f & std::ios_base::fixed) { - number_of_digits = (std::max)(static_cast(number_of_digits + my_exp + 1), std::intmax_t { INT8_C(0) }); + number_of_digits += my_exp + 1; } else if (f & std::ios_base::scientific) ++number_of_digits; From 16992622e9a1cb43d771b3fdc597ebb367b60ac1 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 6 Sep 2025 13:51:02 +0200 Subject: [PATCH 095/114] Clarify matters of syntax --- .../boost/multiprecision/cpp_dec_float.hpp | 13 +++++- test/git_issue_734.cpp | 42 +++++++++++++------ 2 files changed, 41 insertions(+), 14 deletions(-) diff --git a/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index e9ae39f58..79bf0a5ad 100644 --- a/include/boost/multiprecision/cpp_dec_float.hpp +++ b/include/boost/multiprecision/cpp_dec_float.hpp @@ -1932,8 +1932,17 @@ std::string cpp_dec_float::str(std::intmax_t } else if (f & std::ios_base::scientific) ++number_of_digits; - // Determine the number of elements needed to provide the requested digits from cpp_dec_float. - const std::size_t number_of_elements = (std::min)(static_cast(static_cast(number_of_digits / static_cast(cpp_dec_float_elem_digits10)) + 2u), + + // Determine the number of elements needed to provide the requested + // digits from cpp_dec_float. + const std::intmax_t + number_of_elements_signed + { + (std::max)(static_cast(number_of_digits / static_cast(cpp_dec_float_elem_digits10) + 2), + std::intmax_t { INT8_C(0) }) + }; + + const std::size_t number_of_elements = (std::min)(static_cast(number_of_elements_signed), static_cast(cpp_dec_float_elem_number)); // Extract the remaining digits from cpp_dec_float after the decimal point. diff --git a/test/git_issue_734.cpp b/test/git_issue_734.cpp index 10fc2ce7b..77eb1be90 100644 --- a/test/git_issue_734.cpp +++ b/test/git_issue_734.cpp @@ -10,6 +10,7 @@ #include #include #include +#include namespace local { @@ -18,11 +19,17 @@ auto my_stringify_via_top_level_number(const std::streamsize strm_size) -> std:: { using float_type = boost::multiprecision::number; + #if defined(BOOST_MSVC) + using streamsize_type = std::streamsize; + #else + using streamsize_type = int; + #endif + float_type x("0.0000000000000000222222222222222"); std::stringstream strm { }; - strm << std::setprecision(strm_size) << std::fixed; + strm << std::setprecision(static_cast(strm_size)) << std::fixed; strm << x; return strm.str(); @@ -33,11 +40,17 @@ auto my_stringify_via_str_and_backend_str(const std::streamsize strm_size) -> st { using float_type = boost::multiprecision::number; + #if defined(BOOST_MSVC) + using streamsize_type = std::streamsize; + #else + using streamsize_type = int; + #endif + float_type x("0.0000000000000000222222222222222"); std::stringstream strm { }; - strm << std::setprecision(strm_size) << std::fixed; + strm << std::setprecision(static_cast(strm_size)) << std::fixed; return x.str(strm_size, strm.flags()); } @@ -45,15 +58,17 @@ auto my_stringify_via_str_and_backend_str(const std::streamsize strm_size) -> st template auto test() -> void { - BOOST_TEST(my_stringify_via_top_level_number(0) == "0"); - BOOST_TEST(my_stringify_via_top_level_number(8) == "0.00000000"); - BOOST_TEST(my_stringify_via_top_level_number(12) == "0.000000000000"); - BOOST_TEST(my_stringify_via_top_level_number(31) == "0.0000000000000000222222222222222"); - - BOOST_TEST(my_stringify_via_str_and_backend_str(0) == "0"); - BOOST_TEST(my_stringify_via_str_and_backend_str(8) == "0.00000000"); - BOOST_TEST(my_stringify_via_str_and_backend_str(12) == "0.000000000000"); - BOOST_TEST(my_stringify_via_str_and_backend_str(31) == "0.0000000000000000222222222222222"); + std::cout << "Testing type of test: " << typeid(BackendType).name() << std::endl; + + BOOST_TEST(my_stringify_via_top_level_number(std::streamsize { INT8_C(0) }) == "0"); + BOOST_TEST(my_stringify_via_top_level_number(std::streamsize { INT8_C(8) }) == "0.00000000"); + BOOST_TEST(my_stringify_via_top_level_number(std::streamsize { INT8_C(12) }) == "0.000000000000"); + BOOST_TEST(my_stringify_via_top_level_number(std::streamsize { INT8_C(31) }) == "0.0000000000000000222222222222222"); + + BOOST_TEST(my_stringify_via_str_and_backend_str(std::streamsize { INT8_C(0) }) == "0"); + BOOST_TEST(my_stringify_via_str_and_backend_str(std::streamsize { INT8_C(8) }) == "0.00000000"); + BOOST_TEST(my_stringify_via_str_and_backend_str(std::streamsize { INT8_C(12) }) == "0.000000000000"); + BOOST_TEST(my_stringify_via_str_and_backend_str(std::streamsize { INT8_C(31) }) == "0.0000000000000000222222222222222"); } } // namespace local @@ -62,7 +77,10 @@ auto main() -> int { local::test>(); local::test>(); - local::test>(); + BOOST_IF_CONSTEXPR(std::numeric_limits::digits >= 53) + { + local::test>(); + } return boost::report_errors(); } From db2bcea38516eb183ff21c491793489d88c056a5 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 6 Sep 2025 15:44:12 +0200 Subject: [PATCH 096/114] Re-correct backend docs --- doc/reference_backend_requirements.qbk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/reference_backend_requirements.qbk b/doc/reference_backend_requirements.qbk index 2047baa27..459bb988b 100644 --- a/doc/reference_backend_requirements.qbk +++ b/doc/reference_backend_requirements.qbk @@ -45,7 +45,7 @@ and `ff` is a variable of type `std::ios_base::fmtflags`. [[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpreted as a valid number.]] [[`b.swap(b)`][`void`][Swaps the contents of its arguments.][`noexcept`]] [[`cb.str(ss, ff)`][`std::string`][Returns the string representation of `b` with `ss` digits and formatted according to the flags set in `ff`. - If `ss` is zero and neither of `std::ios::fixed` and `std::ios::scientific` is set in the float-field, then returns as many digits as are required to reconstruct the original value.][[space]]] + If `ss` is zero and `std::ios_base::fixed` is not set in `ff`, then returns as many digits as are required to reconstruct the original value.][[space]]] [[`b.negate()`][`void`][Negates `b`.][[space]]] [[`cb.compare(cb2)`][`int`][Compares `cb` and `cb2`, returns a value less than zero if `cb < cb2`, a value greater than zero if `cb > cb2` and zero if `cb == cb2`.][`noexcept`]] From 847ac43f504b9a27dc95ef53e5e380c031be5872 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 7 Sep 2025 19:40:41 +0200 Subject: [PATCH 097/114] Add more cpp_double_fp tests and handle warns --- .../boost/multiprecision/cpp_double_fp.hpp | 7 +- performance/performance_test_df_local.cpp | 150 ++++++++++-------- test/Jamfile.v2 | 2 + ...double_float_bessel_versus_bin_and_dec.cpp | 0 4 files changed, 88 insertions(+), 71 deletions(-) rename performance/performance_test_df.cpp => test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp (100%) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index f8bbd9071..9265fea4a 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1528,7 +1528,6 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const constexpr double_float_type one { 1 }; const int fpc_x { eval_fpclassify(x) }; - const int fpc_a { eval_fpclassify(a) }; if (fpc_a == FP_ZERO) { @@ -1781,8 +1780,6 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type top = (n84 * r * (n7920 + (n240 + r2) * r2)); const double_float_type bot = (n665280 + r * (-n332640 + r * (n75600 + r * (-n10080 + r * (n840 + (-n42 + r) * r))))); - constexpr double_float_type one { 1 }; - result = one + (top / bot); // Rescale the result. @@ -1905,8 +1902,6 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type top = (n144 * r) * (n3603600 + r2 * (n120120 + r2 * (n770 + r2))); const double_float_type bot = (n518918400 + r * (-n259459200 + r * (n60540480 + r * (-n8648640 + r * (n831600 + r * (-n55440 + r * (n2520 + r * (-n72 + r)))))))); - constexpr double_float_type one { 1 }; - result = one + (top / bot); // Rescale the result. @@ -2011,7 +2006,7 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const double_float_type x_pow_n_div_n_fact(xh); - result = double_float_type(1U) + x_pow_n_div_n_fact; + result = one + x_pow_n_div_n_fact; double_float_type dummy { }; diff --git a/performance/performance_test_df_local.cpp b/performance/performance_test_df_local.cpp index c833c0b41..6e8ad30ed 100644 --- a/performance/performance_test_df_local.cpp +++ b/performance/performance_test_df_local.cpp @@ -25,10 +25,10 @@ #include #include -#if defined(_MSC_VER) && !defined(__GNUC__) +#if (defined(BOOST_MSVC) && !defined(BOOST_GCC)) #define STOPWATCH_NODISCARD #else -#if (defined(__cplusplus) && (__cplusplus >= 201703L)) +#if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 201703L)) #define STOPWATCH_NODISCARD [[nodiscard]] // NOLINT(cppcoreguidelines-macro-usage) #else #define STOPWATCH_NODISCARD @@ -50,7 +50,7 @@ struct stopwatch } template - static auto elapsed_time(const stopwatch& my_stopwatch) noexcept -> RepresentationRequestedTimeType + static auto elapsed_time(const stopwatch& my_stopwatch) -> RepresentationRequestedTimeType { using local_time_type = RepresentationRequestedTimeType; @@ -107,14 +107,7 @@ struct stopwatch #else - const time_point_type - elapsed_ns - { - static_cast - ( - stop - m_start - ) - }; + const time_point_type elapsed_ns { static_cast(stop - m_start) }; #endif @@ -126,18 +119,6 @@ struct stopwatch namespace util { -template(UINT8_C(10)), - const bool UpperCase = true> -auto baselexical_cast(const UnsignedIntegerType& u, char* first, char* last) -> const char* -{ - constexpr auto my_base = static_cast(BaseRepresentation); - - const auto result = std::to_chars(first, last, u, my_base); - - return result.ptr; -} - template auto util_pseudorandom_time_point_seed() -> UnsignedIntegralType { @@ -151,47 +132,36 @@ auto util_pseudorandom_time_point_seed() -> UnsignedIntegralType std::uniform_int_distribution dist_sgn(UINT32_C( 0), UINT32_C( 1)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) std::uniform_int_distribution dist_dig(UINT32_C(0x31), UINT32_C( 0x39)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) -using eng_sgn_type = std::ranlux24; -using eng_dig_type = std::minstd_rand0; -using eng_exp_type = std::mt19937; +using eng_sgn_type = std::minstd_rand0; +using eng_dig_type = std::mt19937_64; eng_sgn_type eng_sgn; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) eng_dig_type eng_dig; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) -template -auto generate_wide_decimal_value(bool is_positive = false, - int digits10_to_get = std::numeric_limits::digits10 - 2) -> FloatingPointTypeWithStringConstruction +template +auto generate_wide_decimal_value(int digits10_to_get = std::numeric_limits::digits10 - 2) -> std::string { - using local_floating_point_type = FloatingPointTypeWithStringConstruction; + using local_floating_point_type = FloatingPointType; static_assert(std::numeric_limits::digits10 > static_cast(INT8_C(9)), "Error: Floating-point type destination does not have enough digits10"); - std::string str_x(static_cast(digits10_to_get), '0'); + std::string str_x(static_cast(digits10_to_get + 1), '0'); + + // Get the leading digit before the decimal point. + str_x[std::string::size_type { UINT8_C(0) }] = static_cast(dist_dig(eng_dig)); - std::generate(str_x.begin(), + // Insert a decimal point. + str_x[std::string::size_type { UINT8_C(1) }] = '.'; + + std::generate(str_x.begin() + std::string::size_type { UINT8_C(2) }, str_x.end(), []() // NOLINT(modernize-use-trailing-return-type,-warnings-as-errors) { return static_cast(dist_dig(eng_dig)); }); - // Insert a decimal point. - str_x.insert(static_cast(UINT8_C(1)), static_cast(UINT8_C(1)), '.'); - - // Insert either a positive sign or a negative sign - // (always one or the other) depending on the sign of x. - const auto sign_char_to_insert = - static_cast - ( - is_positive - ? '+' - : static_cast((dist_sgn(eng_sgn) != static_cast(UINT8_C(0))) ? '+' : '-') - ); - - str_x.insert(static_cast(UINT8_C(0)), static_cast(UINT8_C(1)), sign_char_to_insert); - - return local_floating_point_type(str_x.c_str()); + return str_x; } template @@ -217,21 +187,31 @@ auto is_close_fraction(const NumericType& a, return result_is_ok; } -auto main() -> int +auto do_trials(const std::size_t trial_count) -> void { + static std::size_t heat_count { }; + + std::cout << "\nheat_count: " << ++heat_count << std::endl; + using dbl_float_type = boost::multiprecision::cpp_double_double; - using dec_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; + + constexpr int local_digits10 = ((std::numeric_limits::digits10 < 32) ? 32 : std::numeric_limits::digits10); + + using dec_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; + using bin_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; #if defined(BOOST_HAS_FLOAT128) using flt_float_type = boost::multiprecision::float128; #endif - constexpr std::size_t trials { UINT32_C(100000) }; + const std::size_t trials { trial_count }; std::vector dbl_float_a_vec (trials); std::vector dbl_float_b_vec (dbl_float_a_vec.size()); std::vector dec_float_a_vec (dbl_float_a_vec.size()); std::vector dec_float_b_vec (dbl_float_a_vec.size()); + std::vector bin_float_a_vec (dbl_float_a_vec.size()); + std::vector bin_float_b_vec (dbl_float_a_vec.size()); #if defined(BOOST_HAS_FLOAT128) std::vector flt_float_a_vec (dbl_float_a_vec.size()); std::vector flt_float_b_vec (dbl_float_a_vec.size()); @@ -239,7 +219,7 @@ auto main() -> int for(std::size_t index { UINT8_C(0) }; index < dbl_float_a_vec.size(); ++index) { - if(std::size_t { index % unsigned { UINT32_C(0x800) } } == std::size_t { UINT8_C(0) }) + if(std::size_t { index % unsigned { UINT32_C(0x1000) } } == std::size_t { UINT8_C(0) }) { eng_sgn.seed(util::util_pseudorandom_time_point_seed()); eng_dig.seed(util::util_pseudorandom_time_point_seed()); @@ -252,25 +232,37 @@ auto main() -> int { dbl_float_type val { }; - if(is_positive && gate != 0) + if(gate != 0) { - while((val = generate_wide_decimal_value(true)) < gate) { ; } + while((val = dbl_float_type(generate_wide_decimal_value())) < gate) { ; } } else { - val = generate_wide_decimal_value(true); + val = dbl_float_type(generate_wide_decimal_value()); + } + + if(is_positive) + { + return val; } + else + { + const bool next_positive { (dist_sgn(eng_sgn) != static_cast(UINT8_C(0))) }; - return val; + return (next_positive ? val : -val); + } } }; - dbl_float_a_vec[index] = dbl_float_type { gen(true, dbl_float_type { 9 } / 8) }; - dbl_float_b_vec[index] = dbl_float_type { gen(true, dbl_float_type { 9 } / 8) }; + dbl_float_a_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; + dbl_float_b_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; dec_float_a_vec[index] = dec_float_type { dbl_float_a_vec[index] }; dec_float_b_vec[index] = dec_float_type { dbl_float_b_vec[index] }; + bin_float_a_vec[index] = bin_float_type { dbl_float_a_vec[index] }; + bin_float_b_vec[index] = bin_float_type { dbl_float_b_vec[index] }; + #if defined(BOOST_HAS_FLOAT128) flt_float_a_vec[index] = flt_float_type { dbl_float_a_vec[index] }; flt_float_b_vec[index] = flt_float_type { dbl_float_b_vec[index] }; @@ -279,6 +271,7 @@ auto main() -> int std::vector dbl_float_c_vec (dbl_float_a_vec.size()); std::vector dec_float_c_vec (dbl_float_a_vec.size()); + std::vector bin_float_c_vec (dbl_float_a_vec.size()); #if defined(BOOST_HAS_FLOAT128) std::vector flt_float_c_vec (dbl_float_a_vec.size()); #endif @@ -289,7 +282,7 @@ auto main() -> int for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - dbl_float_c_vec[count] = boost::multiprecision::cyl_bessel_j(dbl_float_a_vec[count], dbl_float_b_vec[count]); + dbl_float_c_vec[count] = boost::math::cyl_bessel_j(dbl_float_a_vec[count], dbl_float_b_vec[count]); } const double elapsed_dbl { stopwatch_type::elapsed_time(my_stopwatch) }; @@ -298,17 +291,26 @@ auto main() -> int for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - dec_float_c_vec[count] = boost::multiprecision::cyl_bessel_j(dec_float_a_vec[count], dec_float_b_vec[count]); + dec_float_c_vec[count] = boost::math::cyl_bessel_j(dec_float_a_vec[count], dec_float_b_vec[count]); } const double elapsed_dec { stopwatch_type::elapsed_time(my_stopwatch) }; + my_stopwatch.reset(); + + for(std::size_t count { UINT8_C(0) }; count < trials; ++count) + { + bin_float_c_vec[count] = boost::math::cyl_bessel_j(bin_float_a_vec[count], bin_float_b_vec[count]); + } + + const double elapsed_bin { stopwatch_type::elapsed_time(my_stopwatch) }; + #if defined(BOOST_HAS_FLOAT128) my_stopwatch.reset(); for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - flt_float_c_vec[count] = boost::multiprecision::cyl_bessel_j(flt_float_a_vec[count], flt_float_b_vec[count]); + flt_float_c_vec[count] = boost::math::cyl_bessel_j(flt_float_a_vec[count], flt_float_b_vec[count]); } const double elapsed_flt { stopwatch_type::elapsed_time(my_stopwatch) }; @@ -318,37 +320,55 @@ auto main() -> int strm << std::fixed << std::setprecision(3) << "elapsed_dbl : " << elapsed_dbl << "s\n" << std::fixed << std::setprecision(3) << "elapsed_dec : " << elapsed_dec << "s\n" + << std::fixed << std::setprecision(3) << "elapsed_bin : " << elapsed_bin << "s\n" #if defined(BOOST_HAS_FLOAT128) << std::fixed << std::setprecision(3) << "elapsed_flt : " << elapsed_flt << "s\n" #endif << std::fixed << std::setprecision(3) << "ratio (dec/dbl) : " << elapsed_dec / elapsed_dbl << "\n" + << std::fixed << std::setprecision(3) << "ratio (bin/dbl) : " << elapsed_bin / elapsed_dbl << "\n" #if defined(BOOST_HAS_FLOAT128) << std::fixed << std::setprecision(3) << "ratio (flt/dbl) : " << elapsed_flt / elapsed_dbl << "\n" #endif ; + BOOST_TEST(elapsed_dec / elapsed_dbl > 1.0); + BOOST_TEST(elapsed_bin / elapsed_dbl > 1.0); + std::cout << strm.str() << std::endl; std::cout << "verifying results...\n"; std::size_t count { UINT8_C(0) }; - constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 1024 }; + constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 0x400000 }; for(const auto& lhs : dbl_float_c_vec) { const dbl_float_type ctrl_dec { dec_float_c_vec[count] }; - - BOOST_TEST(is_close_fraction(lhs, ctrl_dec, tol_dbl)); - + const dbl_float_type ctrl_bin { bin_float_c_vec[count] }; #if defined(BOOST_HAS_FLOAT128) const dbl_float_type ctrl_flt { flt_float_c_vec[count] }; + #endif + BOOST_TEST(is_close_fraction(lhs, ctrl_dec, tol_dbl)); + BOOST_TEST(is_close_fraction(lhs, ctrl_bin, tol_dbl)); + #if defined(BOOST_HAS_FLOAT128) BOOST_TEST(is_close_fraction(lhs, ctrl_flt, tol_dbl)); #endif ++count; } +} + +auto main() -> int +{ + constexpr std::size_t trials { UINT32_C(0x8000) }; + constexpr std::size_t heats { UINT32_C(0x4) }; + + for(std::size_t heat_count { UINT8_C(0) }; heat_count < heats; ++heat_count) + { + do_trials(trials); + } return boost::report_errors(); } diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 21cfc547f..3cc1f3568 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -512,6 +512,8 @@ test-suite functions_and_limits : [ run test_cpp_bin_float_tgamma.cpp ] [ run test_cpp_dec_float_tgamma.cpp ] + [ run test_cpp_double_float_tgamma.cpp ] + [ run test_cpp_double_float_bessel_versus_bin_and_dec ] [ run test_roots_10k_digits.cpp : # command line diff --git a/performance/performance_test_df.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp similarity index 100% rename from performance/performance_test_df.cpp rename to test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp From 6a3ddc6136505becb2807ffc0a65552c3e50044a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 7 Sep 2025 19:44:55 +0200 Subject: [PATCH 098/114] Repair file confusions --- performance/performance_test_df_local.cpp | 374 ------------ ...double_float_bessel_versus_bin_and_dec.cpp | 559 ++++++++++-------- 2 files changed, 323 insertions(+), 610 deletions(-) delete mode 100644 performance/performance_test_df_local.cpp diff --git a/performance/performance_test_df_local.cpp b/performance/performance_test_df_local.cpp deleted file mode 100644 index 6e8ad30ed..000000000 --- a/performance/performance_test_df_local.cpp +++ /dev/null @@ -1,374 +0,0 @@ -/////////////////////////////////////////////////////////////// -// Copyright Christopher Kormanyos 2024 - 2025. -// Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt - -// This version of "performance_test_df_local.cpp" is intended -// for specific function-by-function comparisons with cpp_double_double. - -#include -#include -#include -#include -#if defined(BOOST_HAS_FLOAT128) -#include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#if (defined(BOOST_MSVC) && !defined(BOOST_GCC)) -#define STOPWATCH_NODISCARD -#else -#if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 201703L)) -#define STOPWATCH_NODISCARD [[nodiscard]] // NOLINT(cppcoreguidelines-macro-usage) -#else -#define STOPWATCH_NODISCARD -#endif -#endif - -namespace concurrency { - -// See also: https://godbolt.org/z/37a4n9f4Y - -struct stopwatch -{ -public: - using time_point_type = std::uintmax_t; - - auto reset() -> void - { - m_start = now(); - } - - template - static auto elapsed_time(const stopwatch& my_stopwatch) -> RepresentationRequestedTimeType - { - using local_time_type = RepresentationRequestedTimeType; - - return - local_time_type - { - static_cast(my_stopwatch.elapsed()) - / local_time_type { UINTMAX_C(1000000000) } - }; - } - - STOPWATCH_NODISCARD static auto now() -> time_point_type - { - #if defined(__CYGWIN__) - - return static_cast(std::clock()); - - #else - - timespec ts { }; - - const int ntsp { timespec_get(&ts, TIME_UTC) }; - - static_cast(ntsp); - - return - static_cast - ( - static_cast(static_cast(ts.tv_sec) * UINTMAX_C(1000000000)) - + static_cast(ts.tv_nsec) - ); - - #endif - } - -private: - time_point_type m_start { now() }; // NOLINT(readability-identifier-naming) - - STOPWATCH_NODISCARD auto elapsed() const -> time_point_type - { - const time_point_type stop { now() }; - - #if defined(__CYGWIN__) - - const time_point_type - elapsed_ns - { - static_cast - ( - static_cast(static_cast(stop - m_start) * UINTMAX_C(1000000000)) - / static_cast(CLOCKS_PER_SEC) - ) - }; - - #else - - const time_point_type elapsed_ns { static_cast(stop - m_start) }; - - #endif - - return elapsed_ns; - } -}; - -} // namespace concurrency - -namespace util { - -template -auto util_pseudorandom_time_point_seed() -> UnsignedIntegralType -{ - using stopwatch_type = concurrency::stopwatch; - - return static_cast(stopwatch_type::now()); -} - -} // namespace util - -std::uniform_int_distribution dist_sgn(UINT32_C( 0), UINT32_C( 1)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) -std::uniform_int_distribution dist_dig(UINT32_C(0x31), UINT32_C( 0x39)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) - -using eng_sgn_type = std::minstd_rand0; -using eng_dig_type = std::mt19937_64; - -eng_sgn_type eng_sgn; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) -eng_dig_type eng_dig; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) - -template -auto generate_wide_decimal_value(int digits10_to_get = std::numeric_limits::digits10 - 2) -> std::string -{ - using local_floating_point_type = FloatingPointType; - - static_assert(std::numeric_limits::digits10 > static_cast(INT8_C(9)), - "Error: Floating-point type destination does not have enough digits10"); - - std::string str_x(static_cast(digits10_to_get + 1), '0'); - - // Get the leading digit before the decimal point. - str_x[std::string::size_type { UINT8_C(0) }] = static_cast(dist_dig(eng_dig)); - - // Insert a decimal point. - str_x[std::string::size_type { UINT8_C(1) }] = '.'; - - std::generate(str_x.begin() + std::string::size_type { UINT8_C(2) }, - str_x.end(), - []() // NOLINT(modernize-use-trailing-return-type,-warnings-as-errors) - { - return static_cast(dist_dig(eng_dig)); - }); - - return str_x; -} - -template -auto is_close_fraction(const NumericType& a, - const NumericType& b, - const NumericType& tol) noexcept -> bool -{ - using std::fabs; - - auto result_is_ok = bool { }; - - if(b == static_cast(0)) - { - result_is_ok = (fabs(a - b) < tol); // LCOV_EXCL_LINE - } - else - { - const auto delta = fabs(1 - (a / b)); - - result_is_ok = (delta < tol); - } - - return result_is_ok; -} - -auto do_trials(const std::size_t trial_count) -> void -{ - static std::size_t heat_count { }; - - std::cout << "\nheat_count: " << ++heat_count << std::endl; - - using dbl_float_type = boost::multiprecision::cpp_double_double; - - constexpr int local_digits10 = ((std::numeric_limits::digits10 < 32) ? 32 : std::numeric_limits::digits10); - - using dec_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; - using bin_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; - #if defined(BOOST_HAS_FLOAT128) - using flt_float_type = boost::multiprecision::float128; - #endif - - const std::size_t trials { trial_count }; - - std::vector dbl_float_a_vec (trials); - std::vector dbl_float_b_vec (dbl_float_a_vec.size()); - - std::vector dec_float_a_vec (dbl_float_a_vec.size()); - std::vector dec_float_b_vec (dbl_float_a_vec.size()); - std::vector bin_float_a_vec (dbl_float_a_vec.size()); - std::vector bin_float_b_vec (dbl_float_a_vec.size()); - #if defined(BOOST_HAS_FLOAT128) - std::vector flt_float_a_vec (dbl_float_a_vec.size()); - std::vector flt_float_b_vec (dbl_float_a_vec.size()); - #endif - - for(std::size_t index { UINT8_C(0) }; index < dbl_float_a_vec.size(); ++index) - { - if(std::size_t { index % unsigned { UINT32_C(0x1000) } } == std::size_t { UINT8_C(0) }) - { - eng_sgn.seed(util::util_pseudorandom_time_point_seed()); - eng_dig.seed(util::util_pseudorandom_time_point_seed()); - } - - auto - gen - { - [](bool is_positive, const dbl_float_type& gate = 0 ) - { - dbl_float_type val { }; - - if(gate != 0) - { - while((val = dbl_float_type(generate_wide_decimal_value())) < gate) { ; } - } - else - { - val = dbl_float_type(generate_wide_decimal_value()); - } - - if(is_positive) - { - return val; - } - else - { - const bool next_positive { (dist_sgn(eng_sgn) != static_cast(UINT8_C(0))) }; - - return (next_positive ? val : -val); - } - } - }; - - dbl_float_a_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; - dbl_float_b_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; - - dec_float_a_vec[index] = dec_float_type { dbl_float_a_vec[index] }; - dec_float_b_vec[index] = dec_float_type { dbl_float_b_vec[index] }; - - bin_float_a_vec[index] = bin_float_type { dbl_float_a_vec[index] }; - bin_float_b_vec[index] = bin_float_type { dbl_float_b_vec[index] }; - - #if defined(BOOST_HAS_FLOAT128) - flt_float_a_vec[index] = flt_float_type { dbl_float_a_vec[index] }; - flt_float_b_vec[index] = flt_float_type { dbl_float_b_vec[index] }; - #endif - } - - std::vector dbl_float_c_vec (dbl_float_a_vec.size()); - std::vector dec_float_c_vec (dbl_float_a_vec.size()); - std::vector bin_float_c_vec (dbl_float_a_vec.size()); - #if defined(BOOST_HAS_FLOAT128) - std::vector flt_float_c_vec (dbl_float_a_vec.size()); - #endif - - using stopwatch_type = concurrency::stopwatch; - - stopwatch_type my_stopwatch { }; - - for(std::size_t count { UINT8_C(0) }; count < trials; ++count) - { - dbl_float_c_vec[count] = boost::math::cyl_bessel_j(dbl_float_a_vec[count], dbl_float_b_vec[count]); - } - - const double elapsed_dbl { stopwatch_type::elapsed_time(my_stopwatch) }; - - my_stopwatch.reset(); - - for(std::size_t count { UINT8_C(0) }; count < trials; ++count) - { - dec_float_c_vec[count] = boost::math::cyl_bessel_j(dec_float_a_vec[count], dec_float_b_vec[count]); - } - - const double elapsed_dec { stopwatch_type::elapsed_time(my_stopwatch) }; - - my_stopwatch.reset(); - - for(std::size_t count { UINT8_C(0) }; count < trials; ++count) - { - bin_float_c_vec[count] = boost::math::cyl_bessel_j(bin_float_a_vec[count], bin_float_b_vec[count]); - } - - const double elapsed_bin { stopwatch_type::elapsed_time(my_stopwatch) }; - - #if defined(BOOST_HAS_FLOAT128) - my_stopwatch.reset(); - - for(std::size_t count { UINT8_C(0) }; count < trials; ++count) - { - flt_float_c_vec[count] = boost::math::cyl_bessel_j(flt_float_a_vec[count], flt_float_b_vec[count]); - } - - const double elapsed_flt { stopwatch_type::elapsed_time(my_stopwatch) }; - #endif - - std::stringstream strm { }; - - strm << std::fixed << std::setprecision(3) << "elapsed_dbl : " << elapsed_dbl << "s\n" - << std::fixed << std::setprecision(3) << "elapsed_dec : " << elapsed_dec << "s\n" - << std::fixed << std::setprecision(3) << "elapsed_bin : " << elapsed_bin << "s\n" - #if defined(BOOST_HAS_FLOAT128) - << std::fixed << std::setprecision(3) << "elapsed_flt : " << elapsed_flt << "s\n" - #endif - << std::fixed << std::setprecision(3) << "ratio (dec/dbl) : " << elapsed_dec / elapsed_dbl << "\n" - << std::fixed << std::setprecision(3) << "ratio (bin/dbl) : " << elapsed_bin / elapsed_dbl << "\n" - #if defined(BOOST_HAS_FLOAT128) - << std::fixed << std::setprecision(3) << "ratio (flt/dbl) : " << elapsed_flt / elapsed_dbl << "\n" - #endif - ; - - BOOST_TEST(elapsed_dec / elapsed_dbl > 1.0); - BOOST_TEST(elapsed_bin / elapsed_dbl > 1.0); - - std::cout << strm.str() << std::endl; - - std::cout << "verifying results...\n"; - - std::size_t count { UINT8_C(0) }; - - constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 0x400000 }; - - for(const auto& lhs : dbl_float_c_vec) - { - const dbl_float_type ctrl_dec { dec_float_c_vec[count] }; - const dbl_float_type ctrl_bin { bin_float_c_vec[count] }; - #if defined(BOOST_HAS_FLOAT128) - const dbl_float_type ctrl_flt { flt_float_c_vec[count] }; - #endif - - BOOST_TEST(is_close_fraction(lhs, ctrl_dec, tol_dbl)); - BOOST_TEST(is_close_fraction(lhs, ctrl_bin, tol_dbl)); - #if defined(BOOST_HAS_FLOAT128) - BOOST_TEST(is_close_fraction(lhs, ctrl_flt, tol_dbl)); - #endif - - ++count; - } -} - -auto main() -> int -{ - constexpr std::size_t trials { UINT32_C(0x8000) }; - constexpr std::size_t heats { UINT32_C(0x4) }; - - for(std::size_t heat_count { UINT8_C(0) }; heat_count < heats; ++heat_count) - { - do_trials(trials); - } - - return boost::report_errors(); -} diff --git a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index 2e3157a88..6e8ad30ed 100644 --- a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp +++ b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp @@ -1,287 +1,374 @@ /////////////////////////////////////////////////////////////// -// Copyright John Maddock 2019. -// Copyright Christopher Kormanyos 2021 - 2025. +// Copyright Christopher Kormanyos 2024 - 2025. // Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt -// This version of "performance_test_df.cpp" is based almost entirely on -// the original "performance_test.cpp". But it has been specifically -// adapted to test various backends in small precision ranges in order -// to check the performance comparison with cpp_double_double. +// This version of "performance_test_df_local.cpp" is intended +// for specific function-by-function comparisons with cpp_double_double. -#include - -#if !defined(TEST_CPP_DOUBLE_FLOAT) -#define TEST_CPP_DOUBLE_FLOAT +#include +#include +#include +#include +#if defined(BOOST_HAS_FLOAT128) +#include #endif -#if !defined(TEST_CPP_BIN_FLOAT) -#define TEST_CPP_BIN_FLOAT +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if (defined(BOOST_MSVC) && !defined(BOOST_GCC)) +#define STOPWATCH_NODISCARD +#else +#if (defined(BOOST_CXX_VERSION) && (BOOST_CXX_VERSION >= 201703L)) +#define STOPWATCH_NODISCARD [[nodiscard]] // NOLINT(cppcoreguidelines-macro-usage) +#else +#define STOPWATCH_NODISCARD #endif - -#if !defined(TEST_CPP_DEC_FLOAT) -#define TEST_CPP_DEC_FLOAT #endif -#if defined(BOOST_HAS_FLOAT128) -#if !defined(TEST_FLOAT128) -#define TEST_FLOAT128 -#endif -#endif +namespace concurrency { -#include +// See also: https://godbolt.org/z/37a4n9f4Y -#if defined(TEST_CPP_DOUBLE_FLOAT) -#include -#endif +struct stopwatch +{ +public: + using time_point_type = std::uintmax_t; -#if defined(TEST_CPP_BIN_FLOAT) -#include -#endif + auto reset() -> void + { + m_start = now(); + } -#if defined(TEST_CPP_BIN_FLOAT) -#include -#endif + template + static auto elapsed_time(const stopwatch& my_stopwatch) -> RepresentationRequestedTimeType + { + using local_time_type = RepresentationRequestedTimeType; -#if defined(TEST_FLOAT128) -#include -#endif + return + local_time_type + { + static_cast(my_stopwatch.elapsed()) + / local_time_type { UINTMAX_C(1000000000) } + }; + } -#include "performance_test_df.hpp" + STOPWATCH_NODISCARD static auto now() -> time_point_type + { + #if defined(__CYGWIN__) -// cd /mnt/c/Users/ckorm/Documents/Ks/PC_Software/Test -// g++ -std=gnu++14 -Wall -Wextra -O3 -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/performance -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/include -I/mnt/c/boost/boost_1_89_0 ./test.cpp -lquadmath -o test + return static_cast(std::clock()); -// -// Keys in order are: -// Category -// Operator -// Type -// Precision -// Time -// -std::map > > > result_table; + #else -unsigned bits_wanted; // for integer types + timespec ts { }; -void quickbook_results() -{ - // - // Keys in order are: - // Category - // Operator - // Type - // Precision - // Time - // - typedef std::map > > >::const_iterator category_iterator; - typedef std::map > >::const_iterator operator_iterator; - typedef std::map >::const_iterator type_iterator; - typedef std::map::const_iterator precision_iterator; - - for (category_iterator i = result_table.begin(); i != result_table.end(); ++i) - { - std::string cat = i->first; - cat[0] = (char)std::toupper((char)cat[0]); - std::cout << "[section:" << i->first << "_performance " << cat << " Type Perfomance]" << std::endl; - - for (operator_iterator j = i->second.begin(); j != i->second.end(); ++j) + const int ntsp { timespec_get(&ts, TIME_UTC) }; + + static_cast(ntsp); + + return + static_cast + ( + static_cast(static_cast(ts.tv_sec) * UINTMAX_C(1000000000)) + + static_cast(ts.tv_nsec) + ); + + #endif + } + +private: + time_point_type m_start { now() }; // NOLINT(readability-identifier-naming) + + STOPWATCH_NODISCARD auto elapsed() const -> time_point_type + { + const time_point_type stop { now() }; + + #if defined(__CYGWIN__) + + const time_point_type + elapsed_ns { - std::string op = j->first; - std::cout << "[table Operator " << op << std::endl; - std::cout << "[[Backend]"; - - for (precision_iterator k = j->second.begin()->second.begin(); k != j->second.begin()->second.end(); ++k) - { - std::cout << "[" << k->first << " Bits]"; - } - std::cout << "]\n"; - - std::vector best_times(j->second.begin()->second.size(), (std::numeric_limits::max)()); - for (unsigned m = 0; m < j->second.begin()->second.size(); ++m) - { - for (type_iterator k = j->second.begin(); k != j->second.end(); ++k) - { - if (m < k->second.size()) - { - precision_iterator l = k->second.begin(); - std::advance(l, m); - if (best_times[m] > l->second) - best_times[m] = l->second ? l->second : best_times[m]; - } - } - } - - for (type_iterator k = j->second.begin(); k != j->second.end(); ++k) - { - std::cout << "[[" << k->first << "]"; - - unsigned m = 0; - for (precision_iterator l = k->second.begin(); l != k->second.end(); ++l) - { - double rel_time = l->second / best_times[m]; - if (rel_time == 1) - std::cout << "[[*" << rel_time << "]"; - else - std::cout << "[" << rel_time; - std::cout << " (" << l->second << "s)]"; - ++m; - } - - std::cout << "]\n"; - } - - std::cout << "]\n"; - } - - std::cout << "[endsect]" << std::endl; - } -} + static_cast + ( + static_cast(static_cast(stop - m_start) * UINTMAX_C(1000000000)) + / static_cast(CLOCKS_PER_SEC) + ) + }; -#if defined(__HAS_INCLUDE) -#if __has_include() -#define HAS_UTSNAME -#include -#endif -#endif -#ifdef _WIN32 -#include -#endif + #else -void quickbook_platform_details() -{ - std::cout << "[table:platform Platform Details\n[[Platform]["; -#ifdef HAS_UTSNAME - utsname name; - uname(&name); - std::cout << name.sysname << " " << name.release << ", version " << name.version << ", " << name.machine << "]]\n"; -#elif defined(_WIN32) - std::cout << "Windows "; -#ifdef _M_AMD64 - std::cout << "x64"; -#elif defined(_M_IX86) - std::cout << "x86"; -#endif - std::cout << "]]\n"; -#endif - std::cout << "[[Compiler][" << BOOST_COMPILER << "]]\n"; - std::cout << "[[Boost][" << BOOST_VERSION << "]]\n"; - std::cout << "[[Run date][" << __DATE__ << "]]\n"; - std::cout << "]\n\n"; -} + const time_point_type elapsed_ns { static_cast(stop - m_start) }; -namespace local { + #endif -void test29(); -void test32(); -void test52(); -void test53(); + return elapsed_ns; + } +}; -#ifdef TEST_CPP_DOUBLE_FLOAT -template -constexpr inline auto (max)(T a, T b) noexcept -> T { return a > b ? a : b; } -#endif +} // namespace concurrency -} // namespace local +namespace util { -int main() +template +auto util_pseudorandom_time_point_seed() -> UnsignedIntegralType { - quickbook_platform_details(); - - local::test29(); - local::test32(); - local::test52(); - #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) - local::test53(); - #endif + using stopwatch_type = concurrency::stopwatch; - quickbook_results(); + return static_cast(stopwatch_type::now()); } -#ifdef TEST_CPP_DOUBLE_FLOAT -using double_float_of_double_type = boost::multiprecision::cpp_double_double; +} // namespace util -constexpr auto digits10_for_performance_test = (local::max)(std::numeric_limits::digits10, 32); -#else -constexpr auto digits10_for_performance_test = 32; -#endif +std::uniform_int_distribution dist_sgn(UINT32_C( 0), UINT32_C( 1)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) +std::uniform_int_distribution dist_dig(UINT32_C(0x31), UINT32_C( 0x39)); // NOLINT(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) + +using eng_sgn_type = std::minstd_rand0; +using eng_dig_type = std::mt19937_64; -void local::test29() +eng_sgn_type eng_sgn; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) +eng_dig_type eng_dig; // NOLINT(cert-msc32-c,cert-msc51-cpp,cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables) + +template +auto generate_wide_decimal_value(int digits10_to_get = std::numeric_limits::digits10 - 2) -> std::string { -#ifdef TEST_CPP_DEC_FLOAT - static_assert(digits10_for_performance_test >= 32, "Error: Too few digits for performance comparison"); + using local_floating_point_type = FloatingPointType; - using cpp_dec_float_type = - boost::multiprecision::number, - boost::multiprecision::et_off>; + static_assert(std::numeric_limits::digits10 > static_cast(INT8_C(9)), + "Error: Floating-point type destination does not have enough digits10"); - test("cpp_dec_float", digits10_for_performance_test); -#endif -} + std::string str_x(static_cast(digits10_to_get + 1), '0'); -void local::test32() -{ -#ifdef TEST_CPP_BIN_FLOAT - static_assert(digits10_for_performance_test >= 32, "Error: Too few digits for performance comparison"); + // Get the leading digit before the decimal point. + str_x[std::string::size_type { UINT8_C(0) }] = static_cast(dist_dig(eng_dig)); - using cpp_bin_float_type = - boost::multiprecision::number, - boost::multiprecision::et_off>; + // Insert a decimal point. + str_x[std::string::size_type { UINT8_C(1) }] = '.'; - test("cpp_bin_float", digits10_for_performance_test); -#endif + std::generate(str_x.begin() + std::string::size_type { UINT8_C(2) }, + str_x.end(), + []() // NOLINT(modernize-use-trailing-return-type,-warnings-as-errors) + { + return static_cast(dist_dig(eng_dig)); + }); + + return str_x; } -void local::test52() +template +auto is_close_fraction(const NumericType& a, + const NumericType& b, + const NumericType& tol) noexcept -> bool { -#ifdef TEST_CPP_DOUBLE_FLOAT - test("cpp_double_fp_backend", digits10_for_performance_test); -#endif + using std::fabs; + + auto result_is_ok = bool { }; + + if(b == static_cast(0)) + { + result_is_ok = (fabs(a - b) < tol); // LCOV_EXCL_LINE + } + else + { + const auto delta = fabs(1 - (a / b)); + + result_is_ok = (delta < tol); + } + + return result_is_ok; } -void local::test53() +auto do_trials(const std::size_t trial_count) -> void { -#if defined(BOOST_HAS_FLOAT128) -#ifdef TEST_FLOAT128 - using boost::multiprecision::float128; + static std::size_t heat_count { }; - test("boost::multiprecision::float128(at)", std::numeric_limits::digits10); -#endif -#endif + std::cout << "\nheat_count: " << ++heat_count << std::endl; + + using dbl_float_type = boost::multiprecision::cpp_double_double; + + constexpr int local_digits10 = ((std::numeric_limits::digits10 < 32) ? 32 : std::numeric_limits::digits10); + + using dec_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; + using bin_float_type = boost::multiprecision::number, boost::multiprecision::et_off>; + #if defined(BOOST_HAS_FLOAT128) + using flt_float_type = boost::multiprecision::float128; + #endif + + const std::size_t trials { trial_count }; + + std::vector dbl_float_a_vec (trials); + std::vector dbl_float_b_vec (dbl_float_a_vec.size()); + + std::vector dec_float_a_vec (dbl_float_a_vec.size()); + std::vector dec_float_b_vec (dbl_float_a_vec.size()); + std::vector bin_float_a_vec (dbl_float_a_vec.size()); + std::vector bin_float_b_vec (dbl_float_a_vec.size()); + #if defined(BOOST_HAS_FLOAT128) + std::vector flt_float_a_vec (dbl_float_a_vec.size()); + std::vector flt_float_b_vec (dbl_float_a_vec.size()); + #endif + + for(std::size_t index { UINT8_C(0) }; index < dbl_float_a_vec.size(); ++index) + { + if(std::size_t { index % unsigned { UINT32_C(0x1000) } } == std::size_t { UINT8_C(0) }) + { + eng_sgn.seed(util::util_pseudorandom_time_point_seed()); + eng_dig.seed(util::util_pseudorandom_time_point_seed()); + } + + auto + gen + { + [](bool is_positive, const dbl_float_type& gate = 0 ) + { + dbl_float_type val { }; + + if(gate != 0) + { + while((val = dbl_float_type(generate_wide_decimal_value())) < gate) { ; } + } + else + { + val = dbl_float_type(generate_wide_decimal_value()); + } + + if(is_positive) + { + return val; + } + else + { + const bool next_positive { (dist_sgn(eng_sgn) != static_cast(UINT8_C(0))) }; + + return (next_positive ? val : -val); + } + } + }; + + dbl_float_a_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; + dbl_float_b_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; + + dec_float_a_vec[index] = dec_float_type { dbl_float_a_vec[index] }; + dec_float_b_vec[index] = dec_float_type { dbl_float_b_vec[index] }; + + bin_float_a_vec[index] = bin_float_type { dbl_float_a_vec[index] }; + bin_float_b_vec[index] = bin_float_type { dbl_float_b_vec[index] }; + + #if defined(BOOST_HAS_FLOAT128) + flt_float_a_vec[index] = flt_float_type { dbl_float_a_vec[index] }; + flt_float_b_vec[index] = flt_float_type { dbl_float_b_vec[index] }; + #endif + } + + std::vector dbl_float_c_vec (dbl_float_a_vec.size()); + std::vector dec_float_c_vec (dbl_float_a_vec.size()); + std::vector bin_float_c_vec (dbl_float_a_vec.size()); + #if defined(BOOST_HAS_FLOAT128) + std::vector flt_float_c_vec (dbl_float_a_vec.size()); + #endif + + using stopwatch_type = concurrency::stopwatch; + + stopwatch_type my_stopwatch { }; + + for(std::size_t count { UINT8_C(0) }; count < trials; ++count) + { + dbl_float_c_vec[count] = boost::math::cyl_bessel_j(dbl_float_a_vec[count], dbl_float_b_vec[count]); + } + + const double elapsed_dbl { stopwatch_type::elapsed_time(my_stopwatch) }; + + my_stopwatch.reset(); + + for(std::size_t count { UINT8_C(0) }; count < trials; ++count) + { + dec_float_c_vec[count] = boost::math::cyl_bessel_j(dec_float_a_vec[count], dec_float_b_vec[count]); + } + + const double elapsed_dec { stopwatch_type::elapsed_time(my_stopwatch) }; + + my_stopwatch.reset(); + + for(std::size_t count { UINT8_C(0) }; count < trials; ++count) + { + bin_float_c_vec[count] = boost::math::cyl_bessel_j(bin_float_a_vec[count], bin_float_b_vec[count]); + } + + const double elapsed_bin { stopwatch_type::elapsed_time(my_stopwatch) }; + + #if defined(BOOST_HAS_FLOAT128) + my_stopwatch.reset(); + + for(std::size_t count { UINT8_C(0) }; count < trials; ++count) + { + flt_float_c_vec[count] = boost::math::cyl_bessel_j(flt_float_a_vec[count], flt_float_b_vec[count]); + } + + const double elapsed_flt { stopwatch_type::elapsed_time(my_stopwatch) }; + #endif + + std::stringstream strm { }; + + strm << std::fixed << std::setprecision(3) << "elapsed_dbl : " << elapsed_dbl << "s\n" + << std::fixed << std::setprecision(3) << "elapsed_dec : " << elapsed_dec << "s\n" + << std::fixed << std::setprecision(3) << "elapsed_bin : " << elapsed_bin << "s\n" + #if defined(BOOST_HAS_FLOAT128) + << std::fixed << std::setprecision(3) << "elapsed_flt : " << elapsed_flt << "s\n" + #endif + << std::fixed << std::setprecision(3) << "ratio (dec/dbl) : " << elapsed_dec / elapsed_dbl << "\n" + << std::fixed << std::setprecision(3) << "ratio (bin/dbl) : " << elapsed_bin / elapsed_dbl << "\n" + #if defined(BOOST_HAS_FLOAT128) + << std::fixed << std::setprecision(3) << "ratio (flt/dbl) : " << elapsed_flt / elapsed_dbl << "\n" + #endif + ; + + BOOST_TEST(elapsed_dec / elapsed_dbl > 1.0); + BOOST_TEST(elapsed_bin / elapsed_dbl > 1.0); + + std::cout << strm.str() << std::endl; + + std::cout << "verifying results...\n"; + + std::size_t count { UINT8_C(0) }; + + constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 0x400000 }; + + for(const auto& lhs : dbl_float_c_vec) + { + const dbl_float_type ctrl_dec { dec_float_c_vec[count] }; + const dbl_float_type ctrl_bin { bin_float_c_vec[count] }; + #if defined(BOOST_HAS_FLOAT128) + const dbl_float_type ctrl_flt { flt_float_c_vec[count] }; + #endif + + BOOST_TEST(is_close_fraction(lhs, ctrl_dec, tol_dbl)); + BOOST_TEST(is_close_fraction(lhs, ctrl_bin, tol_dbl)); + #if defined(BOOST_HAS_FLOAT128) + BOOST_TEST(is_close_fraction(lhs, ctrl_flt, tol_dbl)); + #endif + + ++count; + } } -#if 0 - -See also: https://github.com/BoostGSoC21/multiprecision/issues/178#issuecomment-2580157139 - -## section:float_performance Float Type Perfomance - -| Operation | `float128` |`cpp_bin_float<32>` | `cpp_dec_float<32>` | `cpp_double_fp_backend` | -|---------------------------------|----------------------|------------------------|------------------------|---------------------------------| -| `*` | 1.45209 (0.0530208s) | 1.4866 (0.054281s) | 4.38403 (0.160076s) | [*1] (0.0365135s) | -| `*(int)` | 1.54876 (0.0396009s) | 2.08722 (0.0533689s) | 5.97016 (0.152653s) | [*1] (0.0255694s) | -| `*(unsigned long long)` | 1.66579 (0.083952s) | 1.109 (0.0558912s) | 3.64263 (0.18358s) | [*1] (0.0503976s) | -| `*=(unsigned long long)` | 1.70531 (0.0858822s) | 1.06861 (0.053817s) | 3.47129 (0.17482s) | [*1] (0.0503617s) | -| `+` | 2.4858 (0.0430852s) | 5.38736 (0.0933768s) | 3.06832 (0.0531818s) | [*1] (0.0173326s) | -| `+(int)` | 2.96871 (0.0360276s) | 7.95354 (0.0965222s) | 5.97545 (0.0725166s) | [*1] (0.0121358s) | -| `+(unsigned long long)` | 3.38383 (0.0739771s) | 5.51557 (0.120581s) | 4.42454 (0.0967292s) | [*1] (0.021862s) | -| `+=(unsigned long long)` | 3.3944 (0.0760423s) | 4.98724 (0.111726s) | 3.92369 (0.0878995s) | [*1] (0.0224023s) | -| `-` | 2.20087 (0.0389465s) | 5.40743 (0.0956897s) | 3.24191 (0.0573686s) | [*1] (0.0176959s) | -| `-(int)` | 3.21093 (0.0383358s) | 8.65589 (0.103344s) | 7.53768 (0.0899936s) | [*1] (0.0119392s) | -| `-(unsigned long long)` | 3.45536 (0.075553s) | 5.17747 (0.113208s) | 4.63221 (0.101285s) | [*1] (0.0218654s) | -| `-=(unsigned long long)` | 2.73635 (0.0764208s) | 3.773 (0.105372s) | 3.39784 (0.0948951s) | [*1] (0.027928s) | -| `/` | 1.38437 (0.148412s) | 7.55692 (0.810141s) | 23.5198 (2.52144s) | [*1] (0.107205s) | -| `/(int)` | 1.53126 (0.0384472s) | 6.85045 (0.172002s) | 49.004 (1.2304s) | [*1] (0.0251081s) | -| `/(unsigned long long)` | 2.41876 (0.098966s) | 9.80113 (0.401023s) | 30.6916 (1.25578s) | [*1] (0.040916s) | -| `/=(unsigned long long)` | 1.88263 (0.0994829s) | 7.33976 (0.387852s) | 23.6024 (1.24721s) | [*1] (0.0528426s) | -| `construct` | [*1] (0.000550501s) | 4.74042 (0.00260961s) | 13.0381 (0.00717748s) | 3.51129 (0.00193297s) | -| `construct(unsigned long long)` | 5.33373 (0.0401408s) | 2.82475 (0.0212586s) | 3.38482 (0.0254736s) | [*1] (0.00752583s) | -| `construct(unsigned)` | 23.3495 (0.0403851s) | 12.4928 (0.0216075s) | 14.3869 (0.0248834s) | [*1] (0.00172959s) | -| `exp` | 1.37724 (1.66978s) | 5.45487 (6.61357s) | 5.19473 (6.29817s) | [*1] (1.21242s) | -| `log` | [*1] (2.1149s) | 7.38874 (15.6264s) | 27.0206 (57.146s) | 1.10118 (2.32888s) | -| `sqrt` | 25.9413 (0.53951s) | 24.5484 (0.510541s) | 131.925 (2.74368s) | [*1] (0.0207973s) | -| `str` | [*1] (0.000419145s) | 1.50425 (0.000630497s) | 1.22795 (0.000514689s) | 1.82207 (0.000763711s) | -| `tan` | 1.3995 (1.69463s) | 5.46528 (6.61782s) | 5.20608 (6.30396s) | [*1] (1.21088s) | +auto main() -> int +{ + constexpr std::size_t trials { UINT32_C(0x8000) }; + constexpr std::size_t heats { UINT32_C(0x4) }; -#endif + for(std::size_t heat_count { UINT8_C(0) }; heat_count < heats; ++heat_count) + { + do_trials(trials); + } + + return boost::report_errors(); +} From 88522344c4e9efb56b5e1f79228030ceb336b6a7 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sun, 7 Sep 2025 21:14:52 +0200 Subject: [PATCH 099/114] Repair typo in file name cpp extension --- test/Jamfile.v2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 3cc1f3568..5d8f323da 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -513,7 +513,7 @@ test-suite functions_and_limits : [ run test_cpp_bin_float_tgamma.cpp ] [ run test_cpp_dec_float_tgamma.cpp ] [ run test_cpp_double_float_tgamma.cpp ] - [ run test_cpp_double_float_bessel_versus_bin_and_dec ] + [ run test_cpp_double_float_bessel_versus_bin_and_dec.cpp ] [ run test_roots_10k_digits.cpp : # command line From 7bf5aaf31a665f4c6a11e6a4bb6152b7af8c317b Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 8 Sep 2025 08:57:07 +0200 Subject: [PATCH 100/114] Try repair GNU mode configs --- test/Jamfile.v2 | 4 ++-- test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 5d8f323da..27862f93b 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -512,8 +512,8 @@ test-suite functions_and_limits : [ run test_cpp_bin_float_tgamma.cpp ] [ run test_cpp_dec_float_tgamma.cpp ] - [ run test_cpp_double_float_tgamma.cpp ] - [ run test_cpp_double_float_bessel_versus_bin_and_dec.cpp ] + [ run test_cpp_double_float_tgamma.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_cpp_double_float_bessel_versus_bin_and_dec.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_roots_10k_digits.cpp : # command line diff --git a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index 6e8ad30ed..69ec8ef33 100644 --- a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp +++ b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp @@ -4,8 +4,9 @@ // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt -// This version of "performance_test_df_local.cpp" is intended -// for specific function-by-function comparisons with cpp_double_double. +// This test file is executes a specific function-by-function +// comparison of cpp_double_double with other backends having +// similar digit counts. #include #include @@ -15,7 +16,6 @@ #include #endif -#include #include #include #include @@ -362,7 +362,7 @@ auto do_trials(const std::size_t trial_count) -> void auto main() -> int { - constexpr std::size_t trials { UINT32_C(0x8000) }; + constexpr std::size_t trials { UINT32_C(0x4000) }; constexpr std::size_t heats { UINT32_C(0x4) }; for(std::size_t heat_count { UINT8_C(0) }; heat_count < heats; ++heat_count) From 50f5c670539dff8bfa302cf1cd44a2fe55fe5f96 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 8 Sep 2025 10:36:22 +0200 Subject: [PATCH 101/114] Exclude selected lines from coverage --- test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index 69ec8ef33..ee2aea7e4 100644 --- a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp +++ b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp @@ -162,7 +162,7 @@ auto generate_wide_decimal_value(int digits10_to_get = std::numeric_limits auto is_close_fraction(const NumericType& a, @@ -238,19 +238,21 @@ auto do_trials(const std::size_t trial_count) -> void } else { - val = dbl_float_type(generate_wide_decimal_value()); + val = dbl_float_type(generate_wide_decimal_value()); // LCOV_EXCL_LINE } if(is_positive) { return val; } + // LCOV_EXCL_START else { const bool next_positive { (dist_sgn(eng_sgn) != static_cast(UINT8_C(0))) }; - return (next_positive ? val : -val); + return (next_positive ? val : -val); // LCOV_EXCL_LINE } + // LCOV_EXCL_STOP } }; From 0ddffc25cc38d314b4ba03d84778e7352f8095b4 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 8 Sep 2025 11:31:13 +0200 Subject: [PATCH 102/114] Refactor loop for warning issue 733 --- include/boost/multiprecision/cpp_int/bitwise.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/boost/multiprecision/cpp_int/bitwise.hpp b/include/boost/multiprecision/cpp_int/bitwise.hpp index da1539167..3adf32a70 100644 --- a/include/boost/multiprecision/cpp_int/bitwise.hpp +++ b/include/boost/multiprecision/cpp_int/bitwise.hpp @@ -436,7 +436,7 @@ inline BOOST_MP_CXX14_CONSTEXPR void left_shift_generic(Int& result, double_limb ++i; } } - for (; rs - i >= static_cast(static_cast(2u) + offset); ++i) + for (; static_cast(static_cast(rs) - static_cast(i)) >= static_cast(2 + static_cast(offset)); ++i) { pr[rs - 1 - i] = pr[rs - 1 - i - offset] << shift; pr[rs - 1 - i] |= pr[rs - 2 - i - offset] >> (Int::limb_bits - shift); From 2f408a18738a107ee27650598b813632750115bc Mon Sep 17 00:00:00 2001 From: Matt Borland Date: Thu, 18 Sep 2025 07:50:40 +0200 Subject: [PATCH 103/114] Stop using ccache in codecov run --- .github/workflows/codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index c739a4cb2..5f1a02ec2 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -61,7 +61,7 @@ jobs: #timeout-minutes: 120 runs-on: ${{matrix.os}} container: ${{matrix.container}} - env: {B2_USE_CCACHE: 1} + env: {B2_USE_CCACHE: 0} steps: - name: Setup environment From ef77359b2b9f2a58b18d7e2676400ee7c24bdc1a Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 20 Sep 2025 08:40:20 +0200 Subject: [PATCH 104/114] Simplify syntax cpp_double_fp_backend --- .../cpp_df_qf/cpp_df_qf_detail_constants.hpp | 2 +- .../boost/multiprecision/cpp_double_fp.hpp | 76 ++--- performance/performance_test_df.cpp | 287 ++++++++++++++++++ ...double_float_bessel_versus_bin_and_dec.cpp | 35 ++- 4 files changed, 348 insertions(+), 52 deletions(-) create mode 100644 performance/performance_test_df.cpp diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp index 6fed97547..fad4d9118 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp @@ -12,7 +12,7 @@ #include - #if (defined(__GNUC__) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) + #if (defined(BOOST_GCC) && defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128)) // // This is the only way we can avoid // warning: non-standard suffix on floating constant [-Wpedantic] diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 9265fea4a..e4aaea23d 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -249,11 +249,7 @@ class cpp_double_fp_backend typename ::std::enable_if<( cpp_df_qf_detail::is_floating_point::value && (!std::is_same::value))>::type const* = nullptr> constexpr cpp_double_fp_backend(const cpp_double_fp_backend& a) - : cpp_double_fp_backend(a.my_first()) - { - // TBD: Maybe specialize this constructor for cases either wider or less wide. - operator+=(a.my_second()); - } + : cpp_double_fp_backend(cpp_double_fp_backend(a.my_first()) + a.my_second()) { } // Constructors from integers. template ::value, long double, @@ -399,10 +392,8 @@ class cpp_double_fp_backend using local_float_type = float_type; #endif - boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.first, &n_first))); - boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.second, &n_second))); - boost::multiprecision::detail::hash_combine(result, n_first); - boost::multiprecision::detail::hash_combine(result, n_second); + boost::multiprecision::detail::hash_combine(result, static_cast(data.first)); + boost::multiprecision::detail::hash_combine(result, static_cast(data.second)); return result; } @@ -895,9 +886,9 @@ class cpp_double_fp_backend // Use cpp_bin_float when writing to string. This is similar // to the use of cpp_bin_float when reading from string. - cpp_bin_float_read_write_type f_bin { data.first }; + cpp_bin_float_read_write_backend_type f_bin { data.first }; - f_bin += data.second; + eval_add(f_bin, cpp_bin_float_read_write_backend_type(data.second)); return f_bin.str(number_of_digits, format_flags); } @@ -1031,8 +1022,6 @@ class cpp_double_fp_backend using cpp_bin_float_read_write_backend_type = boost::multiprecision::backends::cpp_bin_float(my_digits), digit_base_2, void, int, cpp_df_qf_detail::ccmath::numeric_limits::min_exponent, cpp_df_qf_detail::ccmath::numeric_limits::max_exponent>; using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; - using cpp_bin_float_read_write_type = boost::multiprecision::number; - constexpr auto rd_string(const char* pstr) -> bool; constexpr auto add_unchecked(const cpp_double_fp_backend& v) -> void @@ -1173,9 +1162,11 @@ class cpp_double_fp_backend template constexpr auto cpp_double_fp_backend::rd_string(const char* pstr) -> bool { - cpp_bin_float_read_write_type f_bin { pstr }; + cpp_bin_float_read_write_backend_type f_bin { }; + + f_bin = pstr; - const int fpc { fpclassify(f_bin) }; + const int fpc { eval_fpclassify(f_bin) }; const bool is_definitely_nan { (fpc == FP_NAN) }; @@ -1187,18 +1178,20 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p } else { - const bool b_neg { (signbit(f_bin) == 1) }; + const bool b_neg { (eval_signbit(f_bin) == 1) }; - if (b_neg) { f_bin = -f_bin; } + if (b_neg) { f_bin.negate(); } const int expval_from_f_bin { [&f_bin]() { - int expval; + int expval { }; + + cpp_bin_float_read_write_backend_type dummy { }; - frexp(f_bin, &expval); + eval_frexp(dummy, f_bin, &expval); return expval; }() @@ -1217,7 +1210,15 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p } else { - const auto is_definitely_inf = (f_bin > (::std::numeric_limits::max)()); + // TBD: This is the last use of cpp_bin_float_read_write_type + // (instead of using the backend cpp_bin_float type). Can this + // usage be removed and we then use only the backend type? + + using cpp_bin_float_read_write_type = boost::multiprecision::number; + + const cpp_bin_float_read_write_backend_type f_bin_max((::std::numeric_limits::max)().backend()); + + const bool is_definitely_inf { (f_bin.compare(f_bin_max) == 1) }; if (is_definitely_inf) { @@ -1241,27 +1242,32 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p if (has_pow2_scaling_for_small_input) { - f_bin = ldexp(f_bin, pow2_scaling_for_small_input); + eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); } - constexpr auto dig_lim = - static_cast - ( - static_cast + constexpr unsigned + digit_limit + { + static_cast ( - (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) - + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) + static_cast + ( + (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) + + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) + ) + * cpp_df_qf_detail::ccmath::numeric_limits::digits ) - * cpp_df_qf_detail::ccmath::numeric_limits::digits - ); + }; for(auto i = static_cast(UINT8_C(0)); - i < dig_lim; + i < digit_limit; i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) { - const local_builtin_float_type f { static_cast(f_bin) }; + local_builtin_float_type f { }; + + eval_convert_to(&f, f_bin); - f_bin -= cpp_bin_float_read_write_type { f }; + eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(f)); eval_add(*this, local_double_fp_type { f }); } diff --git a/performance/performance_test_df.cpp b/performance/performance_test_df.cpp new file mode 100644 index 000000000..2e3157a88 --- /dev/null +++ b/performance/performance_test_df.cpp @@ -0,0 +1,287 @@ +/////////////////////////////////////////////////////////////// +// Copyright John Maddock 2019. +// Copyright Christopher Kormanyos 2021 - 2025. +// Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt + +// This version of "performance_test_df.cpp" is based almost entirely on +// the original "performance_test.cpp". But it has been specifically +// adapted to test various backends in small precision ranges in order +// to check the performance comparison with cpp_double_double. + +#include + +#if !defined(TEST_CPP_DOUBLE_FLOAT) +#define TEST_CPP_DOUBLE_FLOAT +#endif + +#if !defined(TEST_CPP_BIN_FLOAT) +#define TEST_CPP_BIN_FLOAT +#endif + +#if !defined(TEST_CPP_DEC_FLOAT) +#define TEST_CPP_DEC_FLOAT +#endif + +#if defined(BOOST_HAS_FLOAT128) +#if !defined(TEST_FLOAT128) +#define TEST_FLOAT128 +#endif +#endif + +#include + +#if defined(TEST_CPP_DOUBLE_FLOAT) +#include +#endif + +#if defined(TEST_CPP_BIN_FLOAT) +#include +#endif + +#if defined(TEST_CPP_BIN_FLOAT) +#include +#endif + +#if defined(TEST_FLOAT128) +#include +#endif + +#include "performance_test_df.hpp" + +// cd /mnt/c/Users/ckorm/Documents/Ks/PC_Software/Test +// g++ -std=gnu++14 -Wall -Wextra -O3 -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/performance -I/mnt/c/ChrisGitRepos/modular_boost/multiprecision/include -I/mnt/c/boost/boost_1_89_0 ./test.cpp -lquadmath -o test + +// +// Keys in order are: +// Category +// Operator +// Type +// Precision +// Time +// +std::map > > > result_table; + +unsigned bits_wanted; // for integer types + +void quickbook_results() +{ + // + // Keys in order are: + // Category + // Operator + // Type + // Precision + // Time + // + typedef std::map > > >::const_iterator category_iterator; + typedef std::map > >::const_iterator operator_iterator; + typedef std::map >::const_iterator type_iterator; + typedef std::map::const_iterator precision_iterator; + + for (category_iterator i = result_table.begin(); i != result_table.end(); ++i) + { + std::string cat = i->first; + cat[0] = (char)std::toupper((char)cat[0]); + std::cout << "[section:" << i->first << "_performance " << cat << " Type Perfomance]" << std::endl; + + for (operator_iterator j = i->second.begin(); j != i->second.end(); ++j) + { + std::string op = j->first; + std::cout << "[table Operator " << op << std::endl; + std::cout << "[[Backend]"; + + for (precision_iterator k = j->second.begin()->second.begin(); k != j->second.begin()->second.end(); ++k) + { + std::cout << "[" << k->first << " Bits]"; + } + std::cout << "]\n"; + + std::vector best_times(j->second.begin()->second.size(), (std::numeric_limits::max)()); + for (unsigned m = 0; m < j->second.begin()->second.size(); ++m) + { + for (type_iterator k = j->second.begin(); k != j->second.end(); ++k) + { + if (m < k->second.size()) + { + precision_iterator l = k->second.begin(); + std::advance(l, m); + if (best_times[m] > l->second) + best_times[m] = l->second ? l->second : best_times[m]; + } + } + } + + for (type_iterator k = j->second.begin(); k != j->second.end(); ++k) + { + std::cout << "[[" << k->first << "]"; + + unsigned m = 0; + for (precision_iterator l = k->second.begin(); l != k->second.end(); ++l) + { + double rel_time = l->second / best_times[m]; + if (rel_time == 1) + std::cout << "[[*" << rel_time << "]"; + else + std::cout << "[" << rel_time; + std::cout << " (" << l->second << "s)]"; + ++m; + } + + std::cout << "]\n"; + } + + std::cout << "]\n"; + } + + std::cout << "[endsect]" << std::endl; + } +} + +#if defined(__HAS_INCLUDE) +#if __has_include() +#define HAS_UTSNAME +#include +#endif +#endif +#ifdef _WIN32 +#include +#endif + +void quickbook_platform_details() +{ + std::cout << "[table:platform Platform Details\n[[Platform]["; +#ifdef HAS_UTSNAME + utsname name; + uname(&name); + std::cout << name.sysname << " " << name.release << ", version " << name.version << ", " << name.machine << "]]\n"; +#elif defined(_WIN32) + std::cout << "Windows "; +#ifdef _M_AMD64 + std::cout << "x64"; +#elif defined(_M_IX86) + std::cout << "x86"; +#endif + std::cout << "]]\n"; +#endif + std::cout << "[[Compiler][" << BOOST_COMPILER << "]]\n"; + std::cout << "[[Boost][" << BOOST_VERSION << "]]\n"; + std::cout << "[[Run date][" << __DATE__ << "]]\n"; + std::cout << "]\n\n"; +} + +namespace local { + +void test29(); +void test32(); +void test52(); +void test53(); + +#ifdef TEST_CPP_DOUBLE_FLOAT +template +constexpr inline auto (max)(T a, T b) noexcept -> T { return a > b ? a : b; } +#endif + +} // namespace local + +int main() +{ + quickbook_platform_details(); + + local::test29(); + local::test32(); + local::test52(); + #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) + local::test53(); + #endif + + quickbook_results(); +} + +#ifdef TEST_CPP_DOUBLE_FLOAT +using double_float_of_double_type = boost::multiprecision::cpp_double_double; + +constexpr auto digits10_for_performance_test = (local::max)(std::numeric_limits::digits10, 32); +#else +constexpr auto digits10_for_performance_test = 32; +#endif + +void local::test29() +{ +#ifdef TEST_CPP_DEC_FLOAT + static_assert(digits10_for_performance_test >= 32, "Error: Too few digits for performance comparison"); + + using cpp_dec_float_type = + boost::multiprecision::number, + boost::multiprecision::et_off>; + + test("cpp_dec_float", digits10_for_performance_test); +#endif +} + +void local::test32() +{ +#ifdef TEST_CPP_BIN_FLOAT + static_assert(digits10_for_performance_test >= 32, "Error: Too few digits for performance comparison"); + + using cpp_bin_float_type = + boost::multiprecision::number, + boost::multiprecision::et_off>; + + test("cpp_bin_float", digits10_for_performance_test); +#endif +} + +void local::test52() +{ +#ifdef TEST_CPP_DOUBLE_FLOAT + test("cpp_double_fp_backend", digits10_for_performance_test); +#endif +} + +void local::test53() +{ +#if defined(BOOST_HAS_FLOAT128) +#ifdef TEST_FLOAT128 + using boost::multiprecision::float128; + + test("boost::multiprecision::float128(at)", std::numeric_limits::digits10); +#endif +#endif +} + +#if 0 + +See also: https://github.com/BoostGSoC21/multiprecision/issues/178#issuecomment-2580157139 + +## section:float_performance Float Type Perfomance + +| Operation | `float128` |`cpp_bin_float<32>` | `cpp_dec_float<32>` | `cpp_double_fp_backend` | +|---------------------------------|----------------------|------------------------|------------------------|---------------------------------| +| `*` | 1.45209 (0.0530208s) | 1.4866 (0.054281s) | 4.38403 (0.160076s) | [*1] (0.0365135s) | +| `*(int)` | 1.54876 (0.0396009s) | 2.08722 (0.0533689s) | 5.97016 (0.152653s) | [*1] (0.0255694s) | +| `*(unsigned long long)` | 1.66579 (0.083952s) | 1.109 (0.0558912s) | 3.64263 (0.18358s) | [*1] (0.0503976s) | +| `*=(unsigned long long)` | 1.70531 (0.0858822s) | 1.06861 (0.053817s) | 3.47129 (0.17482s) | [*1] (0.0503617s) | +| `+` | 2.4858 (0.0430852s) | 5.38736 (0.0933768s) | 3.06832 (0.0531818s) | [*1] (0.0173326s) | +| `+(int)` | 2.96871 (0.0360276s) | 7.95354 (0.0965222s) | 5.97545 (0.0725166s) | [*1] (0.0121358s) | +| `+(unsigned long long)` | 3.38383 (0.0739771s) | 5.51557 (0.120581s) | 4.42454 (0.0967292s) | [*1] (0.021862s) | +| `+=(unsigned long long)` | 3.3944 (0.0760423s) | 4.98724 (0.111726s) | 3.92369 (0.0878995s) | [*1] (0.0224023s) | +| `-` | 2.20087 (0.0389465s) | 5.40743 (0.0956897s) | 3.24191 (0.0573686s) | [*1] (0.0176959s) | +| `-(int)` | 3.21093 (0.0383358s) | 8.65589 (0.103344s) | 7.53768 (0.0899936s) | [*1] (0.0119392s) | +| `-(unsigned long long)` | 3.45536 (0.075553s) | 5.17747 (0.113208s) | 4.63221 (0.101285s) | [*1] (0.0218654s) | +| `-=(unsigned long long)` | 2.73635 (0.0764208s) | 3.773 (0.105372s) | 3.39784 (0.0948951s) | [*1] (0.027928s) | +| `/` | 1.38437 (0.148412s) | 7.55692 (0.810141s) | 23.5198 (2.52144s) | [*1] (0.107205s) | +| `/(int)` | 1.53126 (0.0384472s) | 6.85045 (0.172002s) | 49.004 (1.2304s) | [*1] (0.0251081s) | +| `/(unsigned long long)` | 2.41876 (0.098966s) | 9.80113 (0.401023s) | 30.6916 (1.25578s) | [*1] (0.040916s) | +| `/=(unsigned long long)` | 1.88263 (0.0994829s) | 7.33976 (0.387852s) | 23.6024 (1.24721s) | [*1] (0.0528426s) | +| `construct` | [*1] (0.000550501s) | 4.74042 (0.00260961s) | 13.0381 (0.00717748s) | 3.51129 (0.00193297s) | +| `construct(unsigned long long)` | 5.33373 (0.0401408s) | 2.82475 (0.0212586s) | 3.38482 (0.0254736s) | [*1] (0.00752583s) | +| `construct(unsigned)` | 23.3495 (0.0403851s) | 12.4928 (0.0216075s) | 14.3869 (0.0248834s) | [*1] (0.00172959s) | +| `exp` | 1.37724 (1.66978s) | 5.45487 (6.61357s) | 5.19473 (6.29817s) | [*1] (1.21242s) | +| `log` | [*1] (2.1149s) | 7.38874 (15.6264s) | 27.0206 (57.146s) | 1.10118 (2.32888s) | +| `sqrt` | 25.9413 (0.53951s) | 24.5484 (0.510541s) | 131.925 (2.74368s) | [*1] (0.0207973s) | +| `str` | [*1] (0.000419145s) | 1.50425 (0.000630497s) | 1.22795 (0.000514689s) | 1.82207 (0.000763711s) | +| `tan` | 1.3995 (1.69463s) | 5.46528 (6.61782s) | 5.20608 (6.30396s) | [*1] (1.21088s) | + +#endif diff --git a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index ee2aea7e4..5068f968d 100644 --- a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp +++ b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp @@ -4,7 +4,7 @@ // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt -// This test file is executes a specific function-by-function +// This test file executes a specific function-by-function // comparison of cpp_double_double with other backends having // similar digit counts. @@ -149,10 +149,10 @@ auto generate_wide_decimal_value(int digits10_to_get = std::numeric_limits(digits10_to_get + 1), '0'); // Get the leading digit before the decimal point. - str_x[std::string::size_type { UINT8_C(0) }] = static_cast(dist_dig(eng_dig)); + str_x.at(std::string::size_type { UINT8_C(0) }) = static_cast(dist_dig(eng_dig)); // Insert a decimal point. - str_x[std::string::size_type { UINT8_C(1) }] = '.'; + str_x.at(std::string::size_type { UINT8_C(1) }) = '.'; std::generate(str_x.begin() + std::string::size_type { UINT8_C(2) }, str_x.end(), @@ -190,6 +190,7 @@ auto is_close_fraction(const NumericType& a, auto do_trials(const std::size_t trial_count) -> void { static std::size_t heat_count { }; + static std::size_t total_count { }; std::cout << "\nheat_count: " << ++heat_count << std::endl; @@ -219,12 +220,14 @@ auto do_trials(const std::size_t trial_count) -> void for(std::size_t index { UINT8_C(0) }; index < dbl_float_a_vec.size(); ++index) { - if(std::size_t { index % unsigned { UINT32_C(0x1000) } } == std::size_t { UINT8_C(0) }) + if(std::size_t { total_count % unsigned { UINT32_C(0x1000) } } == std::size_t { UINT8_C(0) }) { eng_sgn.seed(util::util_pseudorandom_time_point_seed()); eng_dig.seed(util::util_pseudorandom_time_point_seed()); } + ++total_count; + auto gen { @@ -256,18 +259,18 @@ auto do_trials(const std::size_t trial_count) -> void } }; - dbl_float_a_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; - dbl_float_b_vec[index] = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; + dbl_float_a_vec.at(index) = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; + dbl_float_b_vec.at(index) = dbl_float_type { gen(true, dbl_float_type { 11 } / 10) }; - dec_float_a_vec[index] = dec_float_type { dbl_float_a_vec[index] }; - dec_float_b_vec[index] = dec_float_type { dbl_float_b_vec[index] }; + dec_float_a_vec.at(index) = dec_float_type { dbl_float_a_vec.at(index) }; + dec_float_b_vec.at(index) = dec_float_type { dbl_float_b_vec.at(index) }; - bin_float_a_vec[index] = bin_float_type { dbl_float_a_vec[index] }; - bin_float_b_vec[index] = bin_float_type { dbl_float_b_vec[index] }; + bin_float_a_vec.at(index) = bin_float_type { dbl_float_a_vec.at(index) }; + bin_float_b_vec.at(index) = bin_float_type { dbl_float_b_vec.at(index) }; #if defined(BOOST_HAS_FLOAT128) - flt_float_a_vec[index] = flt_float_type { dbl_float_a_vec[index] }; - flt_float_b_vec[index] = flt_float_type { dbl_float_b_vec[index] }; + flt_float_a_vec.at(index) = flt_float_type { dbl_float_a_vec.at(index) }; + flt_float_b_vec.at(index) = flt_float_type { dbl_float_b_vec.at(index) }; #endif } @@ -284,7 +287,7 @@ auto do_trials(const std::size_t trial_count) -> void for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - dbl_float_c_vec[count] = boost::math::cyl_bessel_j(dbl_float_a_vec[count], dbl_float_b_vec[count]); + dbl_float_c_vec.at(count) = boost::math::cyl_bessel_j(dbl_float_a_vec.at(count), dbl_float_b_vec.at(count)); } const double elapsed_dbl { stopwatch_type::elapsed_time(my_stopwatch) }; @@ -293,7 +296,7 @@ auto do_trials(const std::size_t trial_count) -> void for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - dec_float_c_vec[count] = boost::math::cyl_bessel_j(dec_float_a_vec[count], dec_float_b_vec[count]); + dec_float_c_vec.at(count) = boost::math::cyl_bessel_j(dec_float_a_vec.at(count), dec_float_b_vec.at(count)); } const double elapsed_dec { stopwatch_type::elapsed_time(my_stopwatch) }; @@ -302,7 +305,7 @@ auto do_trials(const std::size_t trial_count) -> void for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - bin_float_c_vec[count] = boost::math::cyl_bessel_j(bin_float_a_vec[count], bin_float_b_vec[count]); + bin_float_c_vec.at(count) = boost::math::cyl_bessel_j(bin_float_a_vec.at(count), bin_float_b_vec.at(count)); } const double elapsed_bin { stopwatch_type::elapsed_time(my_stopwatch) }; @@ -312,7 +315,7 @@ auto do_trials(const std::size_t trial_count) -> void for(std::size_t count { UINT8_C(0) }; count < trials; ++count) { - flt_float_c_vec[count] = boost::math::cyl_bessel_j(flt_float_a_vec[count], flt_float_b_vec[count]); + flt_float_c_vec.at(count) = boost::math::cyl_bessel_j(flt_float_a_vec.at(count), flt_float_b_vec.at(count)); } const double elapsed_flt { stopwatch_type::elapsed_time(my_stopwatch) }; From ba43d82c4acbac88bdbfb18d3ad51f2ffb486931 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 20 Sep 2025 09:05:30 +0200 Subject: [PATCH 105/114] Patch up syntax error --- include/boost/multiprecision/cpp_double_fp.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index e4aaea23d..c40ccc215 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -249,7 +249,7 @@ class cpp_double_fp_backend typename ::std::enable_if<( cpp_df_qf_detail::is_floating_point::value && (!std::is_same::value))>::type const* = nullptr> constexpr cpp_double_fp_backend(const cpp_double_fp_backend& a) - : cpp_double_fp_backend(cpp_double_fp_backend(a.my_first()) + a.my_second()) { } + : cpp_double_fp_backend(cpp_double_fp_backend(a.my_first()) += a.my_second()) { } // Constructors from integers. template Date: Sat, 20 Sep 2025 11:07:51 +0200 Subject: [PATCH 106/114] Simplify rd_string() and improve syntax --- .../boost/multiprecision/cpp_double_fp.hpp | 173 +++++++++--------- 1 file changed, 89 insertions(+), 84 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index c40ccc215..2877ce7e9 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -277,7 +277,7 @@ class cpp_double_fp_backend { using local_unsigned_integral_type = UnsignedIntegralType; - if (u > cpp_df_qf_detail::float_mask()) + if (u > cpp_df_qf_detail::float_mask()) { local_unsigned_integral_type local_flt_mask @@ -328,9 +328,9 @@ class cpp_double_fp_backend constexpr cpp_double_fp_backend(const cpp_df_qf_detail::pair& p) noexcept : data(p) { } - cpp_double_fp_backend(const char* s) + cpp_double_fp_backend(const char* p_str) { - *this = s; + *this = p_str; } // Assignment operator. @@ -373,9 +373,9 @@ class cpp_double_fp_backend return operator=(cpp_double_fp_backend(n)); } - auto operator=(const char* v) -> cpp_double_fp_backend& + auto operator=(const char* p_str) -> cpp_double_fp_backend& { - rd_string(v); + rd_string(p_str); return *this; } @@ -1020,9 +1020,8 @@ class cpp_double_fp_backend rep_type data; using cpp_bin_float_read_write_backend_type = boost::multiprecision::backends::cpp_bin_float(my_digits), digit_base_2, void, int, cpp_df_qf_detail::ccmath::numeric_limits::min_exponent, cpp_df_qf_detail::ccmath::numeric_limits::max_exponent>; - using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; - constexpr auto rd_string(const char* pstr) -> bool; + constexpr auto rd_string(const char* p_str) -> bool; constexpr auto add_unchecked(const cpp_double_fp_backend& v) -> void { @@ -1160,11 +1159,11 @@ class cpp_double_fp_backend }; template -constexpr auto cpp_double_fp_backend::rd_string(const char* pstr) -> bool +constexpr auto cpp_double_fp_backend::rd_string(const char* p_str) -> bool { cpp_bin_float_read_write_backend_type f_bin { }; - f_bin = pstr; + f_bin = p_str; const int fpc { eval_fpclassify(f_bin) }; @@ -1175,110 +1174,116 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p if (is_definitely_nan) { static_cast(operator=(local_double_fp_type::my_value_nan())); + + return true; } - else - { - const bool b_neg { (eval_signbit(f_bin) == 1) }; - if (b_neg) { f_bin.negate(); } + const bool b_neg { (eval_signbit(f_bin) == 1) }; + + if (b_neg) { f_bin.negate(); } - const int - expval_from_f_bin + const int + expval_from_f_bin + { + [&f_bin]() { - [&f_bin]() - { - int expval { }; + int expval { }; - cpp_bin_float_read_write_backend_type dummy { }; + cpp_bin_float_read_write_backend_type dummy { }; - eval_frexp(dummy, f_bin, &expval); + eval_frexp(dummy, f_bin, &expval); - return expval; - }() - }; + return expval; + }() + }; - const auto is_zero_or_subnormal = - ( - (fpc == FP_ZERO) - || (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent)) - ); + using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; - if (is_zero_or_subnormal) + const auto is_zero_or_subnormal = + ( + (fpc == FP_ZERO) + || (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent)) + ); + + if (is_zero_or_subnormal) + { + data.first = float_type { 0.0F }; + data.second = float_type { 0.0F }; + } + else + { + bool is_definitely_inf { (fpc == FP_INFINITE) }; + + if (!is_definitely_inf) { - data.first = float_type { 0.0F }; - data.second = float_type { 0.0F }; + float_type flt_inf_check { }; + + eval_convert_to(&flt_inf_check, f_bin); + + if (flt_inf_check > my_value_max().my_first()) + { + is_definitely_inf = true; + } + }; + + if (is_definitely_inf) + { + static_cast(operator=(local_double_fp_type::my_value_inf())); + + if (b_neg) { negate(); } } else { - // TBD: This is the last use of cpp_bin_float_read_write_type - // (instead of using the backend cpp_bin_float type). Can this - // usage be removed and we then use only the backend type? - - using cpp_bin_float_read_write_type = boost::multiprecision::number; + data.first = float_type { 0.0F }; + data.second = float_type { 0.0F }; - const cpp_bin_float_read_write_backend_type f_bin_max((::std::numeric_limits::max)().backend()); + constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; - const bool is_definitely_inf { (f_bin.compare(f_bin_max) == 1) }; + const auto has_pow2_scaling_for_small_input = + ( + expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input) + ); - if (is_definitely_inf) + if (has_pow2_scaling_for_small_input) { - static_cast(operator=(local_double_fp_type::my_value_inf())); - - if (b_neg) { negate(); } + eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); } - else - { - data.first = float_type { 0.0F }; - data.second = float_type { 0.0F }; - using local_builtin_float_type = typename std::conditional<(sizeof(float_type) <= sizeof(double)), double, float_type>::type; + using local_builtin_float_type = typename std::conditional<(sizeof(float_type) <= sizeof(double)), double, float_type>::type; - constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; - - const auto has_pow2_scaling_for_small_input = - ( - expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input) - ); - - if (has_pow2_scaling_for_small_input) + constexpr unsigned + digit_limit { - eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); - } - - constexpr unsigned - digit_limit - { - static_cast + static_cast + ( + static_cast ( - static_cast - ( - (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) - + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) - ) - * cpp_df_qf_detail::ccmath::numeric_limits::digits + (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) + + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) ) - }; + * cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + }; - for(auto i = static_cast(UINT8_C(0)); - i < digit_limit; - i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) - { - local_builtin_float_type f { }; + for(auto i = static_cast(UINT8_C(0)); + i < digit_limit; + i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) + { + local_builtin_float_type flt_part { }; - eval_convert_to(&f, f_bin); + eval_convert_to(&flt_part, f_bin); - eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(f)); + eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(flt_part)); - eval_add(*this, local_double_fp_type { f }); - } - - if (has_pow2_scaling_for_small_input) - { - eval_ldexp(*this, *this, -pow2_scaling_for_small_input); - } + eval_add(*this, local_double_fp_type { flt_part }); + } - if (b_neg) { negate(); } + if (has_pow2_scaling_for_small_input) + { + eval_ldexp(*this, *this, -pow2_scaling_for_small_input); } + + if (b_neg) { negate(); } } } From 156e03e11e076b14432710f16f79d1e8183e17c6 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 20 Sep 2025 13:05:58 +0200 Subject: [PATCH 107/114] Improve rd_string inf-check and add tests --- .../boost/multiprecision/cpp_double_fp.hpp | 131 ++++++++++-------- test/test_various_edges_more.cpp | 54 ++++++++ 2 files changed, 126 insertions(+), 59 deletions(-) diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 2877ce7e9..66da0d4af 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -1161,6 +1161,8 @@ class cpp_double_fp_backend template constexpr auto cpp_double_fp_backend::rd_string(const char* p_str) -> bool { + // Use an intermediate cpp_bin_float backend type for reading string input. + cpp_bin_float_read_write_backend_type f_bin { }; f_bin = p_str; @@ -1197,96 +1199,107 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p }() }; - using cpp_bin_float_read_write_exp_type = typename cpp_bin_float_read_write_backend_type::exponent_type; - const auto is_zero_or_subnormal = ( (fpc == FP_ZERO) - || (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent)) + || (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent)) ); if (is_zero_or_subnormal) { data.first = float_type { 0.0F }; data.second = float_type { 0.0F }; + + return true; } - else - { - bool is_definitely_inf { (fpc == FP_INFINITE) }; - if (!is_definitely_inf) - { - float_type flt_inf_check { }; + float_type flt_inf_check_first { }; - eval_convert_to(&flt_inf_check, f_bin); + eval_convert_to(&flt_inf_check_first, f_bin); - if (flt_inf_check > my_value_max().my_first()) - { - is_definitely_inf = true; - } - }; + bool is_definitely_inf { ((fpc == FP_INFINITE) || cpp_df_qf_detail::ccmath::isinf(flt_inf_check_first)) }; - if (is_definitely_inf) + if (!is_definitely_inf) + { + if (flt_inf_check_first > my_value_max().my_first()) { - static_cast(operator=(local_double_fp_type::my_value_inf())); + cpp_bin_float_read_write_backend_type f_bin_inf_check(f_bin); + + eval_subtract(f_bin_inf_check, cpp_bin_float_read_write_backend_type(flt_inf_check_first)); + + float_type flt_inf_check_second { }; + + eval_convert_to(&flt_inf_check_second, f_bin_inf_check); - if (b_neg) { negate(); } + is_definitely_inf = eval_gt(local_double_fp_type(flt_inf_check_first, flt_inf_check_second), my_value_max()); } - else + }; + + if (is_definitely_inf) + { + static_cast(operator=(local_double_fp_type::my_value_inf())); + + if (b_neg) { - data.first = float_type { 0.0F }; - data.second = float_type { 0.0F }; + negate(); + } - constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; + return true; + } - const auto has_pow2_scaling_for_small_input = - ( - expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input) - ); + // The input string is normal. We will now extract its value. - if (has_pow2_scaling_for_small_input) - { - eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); - } + data.first = float_type { 0.0F }; + data.second = float_type { 0.0F }; - using local_builtin_float_type = typename std::conditional<(sizeof(float_type) <= sizeof(double)), double, float_type>::type; + constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; - constexpr unsigned - digit_limit - { - static_cast - ( - static_cast - ( - (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) - + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) - ) - * cpp_df_qf_detail::ccmath::numeric_limits::digits - ) - }; + const auto has_pow2_scaling_for_small_input = + ( + expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input) + ); - for(auto i = static_cast(UINT8_C(0)); - i < digit_limit; - i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) - { - local_builtin_float_type flt_part { }; + if (has_pow2_scaling_for_small_input) + { + eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); + } + + using local_builtin_float_type = typename std::conditional<(sizeof(float_type) <= sizeof(double)), double, float_type>::type; + + constexpr unsigned + digit_limit + { + static_cast + ( + static_cast + ( + (local_double_fp_type::my_digits / cpp_df_qf_detail::ccmath::numeric_limits::digits) + + (((local_double_fp_type::my_digits % cpp_df_qf_detail::ccmath::numeric_limits::digits) != 0) ? 1 : 0) + ) + * cpp_df_qf_detail::ccmath::numeric_limits::digits + ) + }; - eval_convert_to(&flt_part, f_bin); + for(auto i = static_cast(UINT8_C(0)); + i < digit_limit; + i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) + { + local_builtin_float_type flt_part { }; - eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(flt_part)); + eval_convert_to(&flt_part, f_bin); - eval_add(*this, local_double_fp_type { flt_part }); - } + eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(flt_part)); - if (has_pow2_scaling_for_small_input) - { - eval_ldexp(*this, *this, -pow2_scaling_for_small_input); - } + eval_add(*this, local_double_fp_type { flt_part }); + } - if (b_neg) { negate(); } - } + if (has_pow2_scaling_for_small_input) + { + eval_ldexp(*this, *this, -pow2_scaling_for_small_input); } + if (b_neg) { negate(); } + return true; } diff --git a/test/test_various_edges_more.cpp b/test/test_various_edges_more.cpp index 26e5e9f23..d5f24715b 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -966,6 +966,59 @@ namespace local } } } + + auto test_double_fp_string_gt_max() -> void + { + using float_backend_larger_type = boost::multiprecision::cpp_bin_float<50, boost::multiprecision::digit_base_10, void, std::int32_t>; + + using float_larger_type = boost::multiprecision::number; + + std::mt19937_64 gen { time_point() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.01), + static_cast(1.04) + }; + + { + for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(32)); ++index) + { + const bool make_neg { ((index % unsigned { UINT8_C(2) }) != unsigned { UINT8_C(0) }) }; + + const double dbl_fuzz { 1.0 - dis(gen) * std::numeric_limits::epsilon() }; + + float_larger_type + flt_larger + ( + float_larger_type((std::numeric_limits::max)()) + / dbl_fuzz + ); + + if(make_neg) + { + flt_larger = -flt_larger; + } + + std::stringstream strm { }; + + strm << std::setprecision(std::numeric_limits::max_digits10) + << flt_larger; + + const std::string str_ovf { strm.str() }; + + const boost::multiprecision::cpp_double_double val_ovf(str_ovf.c_str()); + + BOOST_TEST((boost::multiprecision::isinf)(val_ovf)); + + if(make_neg) + { + BOOST_TEST((boost::multiprecision::signbit)(val_ovf)); + } + } + } + } } // namespace local auto main() -> int @@ -1006,6 +1059,7 @@ auto main() -> int static_cast(local::test_edges_ovf_und()); static_cast(local::test_edges_trig()); local::test_frexp_edge(); + local::test_double_fp_string_gt_max(); } { From ecb7de7aec572dbcc76496ada3b59dfbd52d83c3 Mon Sep 17 00:00:00 2001 From: Pavel P Date: Sun, 21 Sep 2025 13:48:42 +0200 Subject: [PATCH 108/114] Disable warnings from deprecated numeric_limits members (clang version) --- .../boost/multiprecision/cpp_int/limits.hpp | 38 ++++++++++++++----- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/include/boost/multiprecision/cpp_int/limits.hpp b/include/boost/multiprecision/cpp_int/limits.hpp index fa29cc48b..309379ea9 100644 --- a/include/boost/multiprecision/cpp_int/limits.hpp +++ b/include/boost/multiprecision/cpp_int/limits.hpp @@ -200,13 +200,22 @@ class numeric_limits, ExpressionTemplates> >::has_quiet_NaN; template constexpr bool numeric_limits, ExpressionTemplates> >::has_signaling_NaN; -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable:4996) +#if defined(__clang__) && defined(__has_warning) +# if __has_warning("-Wdeprecated-declarations") +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +# endif +#elif defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4996) #endif template constexpr float_denorm_style numeric_limits, ExpressionTemplates> >::has_denorm; -#ifdef _MSC_VER -#pragma warning(pop) +#if defined(__clang__) && defined(__has_warning) +# if __has_warning("-Wdeprecated-declarations") +# pragma clang diagnostic pop +# endif +#elif defined(_MSC_VER) +# pragma warning(pop) #endif template constexpr bool numeric_limits, ExpressionTemplates> >::has_denorm_loss; From 6ffeac8e452e9a85372194ba58cfee6a1c9794e1 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 22 Sep 2025 16:05:07 +0200 Subject: [PATCH 109/114] More double_fp syntax improvements --- .../cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp | 17 +- .../boost/multiprecision/cpp_double_fp.hpp | 208 ++++++++++-------- performance/performance_test_df.cpp | 2 +- 3 files changed, 121 insertions(+), 106 deletions(-) diff --git a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp index 368293a5c..644a02314 100644 --- a/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp +++ b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_log.hpp @@ -125,6 +125,8 @@ constexpr auto log_impl(Real x) noexcept -> Real { int n2 { }; + // Scale the argument down. + Real x2 { ::boost::multiprecision::backends::cpp_df_qf_detail::ccmath::detail::frexp_impl(x, &n2) }; if (x2 > static_cast(0.875L)) @@ -134,18 +136,17 @@ constexpr auto log_impl(Real x) noexcept -> Real ++n2; } - Real s { log_impl_pade(x2) }; + // Estimate the logarithm of the argument to roughly half + // the precision of Real. + const Real s { log_impl_pade(x2) }; + // Compute the exponent function to the full precision of Real. const Real E { exp_impl(s) }; - // Do one single step of Newton-Raphson iteration. - s = s + ((x2 - E) / E); - - Real xn2 { static_cast(n2) * constant_ln_two() }; - - s += xn2; + // Perform one single step of Newton-Raphson iteration + // and scale the result back up. - return s; + return (s + ((x2 - E) / E)) + Real { static_cast(n2) * constant_ln_two() }; } // LCOV_EXCL_STOP diff --git a/include/boost/multiprecision/cpp_double_fp.hpp b/include/boost/multiprecision/cpp_double_fp.hpp index 66da0d4af..be199ae63 100644 --- a/include/boost/multiprecision/cpp_double_fp.hpp +++ b/include/boost/multiprecision/cpp_double_fp.hpp @@ -382,8 +382,6 @@ class cpp_double_fp_backend constexpr auto hash() const -> ::std::size_t { - std::size_t result { UINT8_C(0) }; - #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) using local_float_type = typename std::conditional<::std::is_same::value, long double, @@ -392,8 +390,15 @@ class cpp_double_fp_backend using local_float_type = float_type; #endif - boost::multiprecision::detail::hash_combine(result, static_cast(data.first)); - boost::multiprecision::detail::hash_combine(result, static_cast(data.second)); + std::size_t result { UINT8_C(0) }; + + int n_first { }; + int n_second { }; + + boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.first, &n_first))); + boost::multiprecision::detail::hash_combine(result, static_cast(cpp_df_qf_detail::ccmath::frexp(data.second, &n_second))); + boost::multiprecision::detail::hash_combine(result, n_first); + boost::multiprecision::detail::hash_combine(result, n_second); return result; } @@ -408,8 +413,8 @@ class cpp_double_fp_backend { return ( - (data.second == float_type { 0.0F }) - && (data.first == float_type { 1.0F }) + (data.second == float_type { 0.0F }) + && (data.first == float_type { 1.0F }) ); } @@ -425,13 +430,9 @@ class cpp_double_fp_backend } else { - data.first = -data.first; - if (!iszero_unchecked()) { - data.second = -data.second; - - data = arithmetic::normalize(data.first, data.second); + data = arithmetic::normalize(-data.first, -data.second); } } } @@ -725,23 +726,17 @@ class cpp_double_fp_backend float_type u { cpp_df_qf_detail::split_maker::value * v.data.first }; - float_type hv { }; - - if (cpp_df_qf_detail::ccmath::isinf(u)) - { - // Handle overflow by scaling down (and then back up) with the split. - - hv = - cpp_df_qf_detail::ccmath::ldexp - ( - v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, - cpp_df_qf_detail::split_maker::n_shl - ); - } - else - { - hv = u - float_type { u - v.data.first }; - } + const float_type hv = + ( + cpp_df_qf_detail::ccmath::isinf(u) + ? cpp_df_qf_detail::ccmath::ldexp + ( + // Handle overflow by scaling down (and then back up) with the split. + v.data.first - float_type { v.data.first - cpp_df_qf_detail::ccmath::ldexp(v.data.first, -cpp_df_qf_detail::split_maker::n_shl) }, + cpp_df_qf_detail::split_maker::n_shl + ) + : u - float_type { u - v.data.first } + ); const float_type U { C * v.data.first }; @@ -1016,7 +1011,18 @@ class cpp_double_fp_backend ); } - private: + constexpr auto add_unchecked_limb(const float_type v_first) -> void + { + const float_type thi { data.second }; + + data = arithmetic::two_sum(data.first, v_first); + + data = arithmetic::two_hilo_sum(data.first, data.second + thi); + + data = arithmetic::two_hilo_sum(data.first, data.second); + } + +private: rep_type data; using cpp_bin_float_read_write_backend_type = boost::multiprecision::backends::cpp_bin_float(my_digits), digit_base_2, void, int, cpp_df_qf_detail::ccmath::numeric_limits::min_exponent, cpp_df_qf_detail::ccmath::numeric_limits::max_exponent>; @@ -1049,17 +1055,6 @@ class cpp_double_fp_backend data = arithmetic::two_hilo_sum(data.first, thi_tlo.second + data.second); } - constexpr auto add_unchecked_limb(const float_type v_first) -> void - { - const float_type thi { data.second }; - - data = arithmetic::two_sum(data.first, v_first); - - data = arithmetic::two_hilo_sum(data.first, data.second + thi); - - data = arithmetic::two_hilo_sum(data.first, data.second); - } - constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void { // The multiplication algorithm has been taken from Victor Shoup, @@ -1219,20 +1214,17 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p bool is_definitely_inf { ((fpc == FP_INFINITE) || cpp_df_qf_detail::ccmath::isinf(flt_inf_check_first)) }; - if (!is_definitely_inf) + if ((!is_definitely_inf) && (flt_inf_check_first > my_value_max().my_first())) { - if (flt_inf_check_first > my_value_max().my_first()) - { - cpp_bin_float_read_write_backend_type f_bin_inf_check(f_bin); + cpp_bin_float_read_write_backend_type f_bin_inf_check(f_bin); - eval_subtract(f_bin_inf_check, cpp_bin_float_read_write_backend_type(flt_inf_check_first)); + eval_subtract(f_bin_inf_check, cpp_bin_float_read_write_backend_type(flt_inf_check_first)); - float_type flt_inf_check_second { }; + float_type flt_inf_check_second { }; - eval_convert_to(&flt_inf_check_second, f_bin_inf_check); + eval_convert_to(&flt_inf_check_second, f_bin_inf_check); - is_definitely_inf = eval_gt(local_double_fp_type(flt_inf_check_first, flt_inf_check_second), my_value_max()); - } + is_definitely_inf = eval_gt(local_double_fp_type(flt_inf_check_first, flt_inf_check_second), my_value_max()); }; if (is_definitely_inf) @@ -1252,12 +1244,15 @@ constexpr auto cpp_double_fp_backend::rd_string(const char* p data.first = float_type { 0.0F }; data.second = float_type { 0.0F }; + // Handle small input values. Scale (and re-scale them below) if possible. + constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; - const auto has_pow2_scaling_for_small_input = - ( - expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input) - ); + const bool + has_pow2_scaling_for_small_input + { + (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent + pow2_scaling_for_small_input)) + }; if (has_pow2_scaling_for_small_input) { @@ -1755,10 +1750,14 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const } else if (xx.is_one()) { - result = - ((!b_neg) - ? cpp_df_qf_detail::constant_df_exp1() - : double_float_type(1U) / cpp_df_qf_detail::constant_df_exp1()); + if(!b_neg) + { + result = cpp_df_qf_detail::constant_df_exp1(); + } + else + { + eval_divide(result, one, cpp_df_qf_detail::constant_df_exp1()); + } } else { @@ -1766,15 +1765,15 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const double_float_type nf { }; - eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); - // Prepare the scaled variables. - const auto b_scale = (xx.order02() > -1); + const bool b_scale { (xx.order02() > -1) }; double_float_type r { }; if (b_scale) { + eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); + eval_ldexp(r, xx - (nf * cpp_df_qf_detail::constant_df_ln_two()), -2); } else @@ -1801,10 +1800,11 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type r2 { r * r }; // Use the small-argument Pade approximation having coefficients shown above. - const double_float_type top = (n84 * r * (n7920 + (n240 + r2) * r2)); + result = (n84 * r * (n7920 + (n240 + r2) * r2)); const double_float_type bot = (n665280 + r * (-n332640 + r * (n75600 + r * (-n10080 + r * (n840 + (-n42 + r) * r))))); - result = one + (top / bot); + eval_divide(result, bot); + result.add_unchecked_limb(local_float_type { 1.0F }); // Rescale the result. if (b_scale) @@ -1820,13 +1820,13 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (n > 0) { - eval_ldexp(result, double_float_type(result), n); + eval_ldexp(result, result, n); } } if (b_neg) { - result = one / result; + eval_divide(result, one, result); } } } @@ -1877,10 +1877,14 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const } else if (xx.is_one()) { - result = - ((!b_neg) - ? cpp_df_qf_detail::constant_df_exp1() - : double_float_type(1U) / cpp_df_qf_detail::constant_df_exp1()); + if(!b_neg) + { + result = cpp_df_qf_detail::constant_df_exp1(); + } + else + { + eval_divide(result, one, cpp_df_qf_detail::constant_df_exp1()); + } } else { @@ -1888,15 +1892,15 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const double_float_type nf { }; - eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); - // Prepare the scaled variables. - const auto b_scale = (xx.order02() > -4); + const bool b_scale { (xx.order02() > -4) }; double_float_type r { }; if (b_scale) { + eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); + eval_ldexp(r, xx - (nf * cpp_df_qf_detail::constant_df_ln_two()), -4); } else @@ -1923,10 +1927,11 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const const double_float_type r2 { r * r }; - const double_float_type top = (n144 * r) * (n3603600 + r2 * (n120120 + r2 * (n770 + r2))); + result = (n144 * r) * (n3603600 + r2 * (n120120 + r2 * (n770 + r2))); const double_float_type bot = (n518918400 + r * (-n259459200 + r * (n60540480 + r * (-n8648640 + r * (n831600 + r * (-n55440 + r * (n2520 + r * (-n72 + r)))))))); - result = one + (top / bot); + eval_divide(result, bot); + result.add_unchecked_limb(local_float_type { 1.0F }); // Rescale the result. if (b_scale) @@ -1944,13 +1949,13 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (n > 0) { - eval_ldexp(result, double_float_type(result), n); + eval_ldexp(result, result, n); } } if (b_neg) { - result = one / result; + eval_divide(result, one, result); } } } @@ -2001,10 +2006,14 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const } else if (xx.is_one()) { - result = - ((!b_neg) - ? cpp_df_qf_detail::constant_df_exp1() - : double_float_type(1U) / cpp_df_qf_detail::constant_df_exp1()); + if(!b_neg) + { + result = cpp_df_qf_detail::constant_df_exp1(); + } + else + { + eval_divide(result, one, cpp_df_qf_detail::constant_df_exp1()); + } } else { @@ -2012,15 +2021,15 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const double_float_type nf { }; - eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); - // Prepare the scaled variables. - const auto b_scale = (xx.order02() > -4); + const bool b_scale { (xx.order02() > -4) }; double_float_type xh { }; if (b_scale) { + eval_floor(nf, xx / cpp_df_qf_detail::constant_df_ln_two()); + eval_ldexp(xh, xx - (nf * cpp_df_qf_detail::constant_df_ln_two()), -4); } else @@ -2030,29 +2039,30 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const double_float_type x_pow_n_div_n_fact(xh); - result = one + x_pow_n_div_n_fact; + result = x_pow_n_div_n_fact; + result.add_unchecked_limb(local_float_type { 1.0F }); double_float_type dummy { }; - // Series expansion of hypergeometric_0f0(; ; x). + // Use the Taylor series expansion of hypergeometric_0f0(; ; x). // For this high(er) digit count, a scaled argument with subsequent // Taylor series expansion is actually more precise than Pade approximation. - for (unsigned n { 2U }; n < 64U; ++n) + for (unsigned n { UINT8_C(2) }; n < unsigned { UINT8_C(64) }; ++n) { - x_pow_n_div_n_fact *= xh; + eval_multiply(x_pow_n_div_n_fact, xh); - x_pow_n_div_n_fact /= typename double_float_type::float_type(n); + eval_divide(x_pow_n_div_n_fact, double_float_type(n)); int n_tol { }; eval_frexp(dummy, x_pow_n_div_n_fact, &n_tol); - if ((n > 4U) && (n_tol < -(double_float_type::my_digits - 2))) + if ((n > 4U) && (n_tol < -(double_float_type::my_digits - 1))) { break; } - result += x_pow_n_div_n_fact; + eval_add(result, x_pow_n_div_n_fact); } // Rescale the result. @@ -2071,13 +2081,13 @@ constexpr auto eval_exp(cpp_double_fp_backend& result, const if (n > 0) { - eval_ldexp(result, double_float_type(result), n); + eval_ldexp(result, result, n); } } if (b_neg) { - result = one / result; + eval_divide(result, one, result); } } } @@ -2129,18 +2139,22 @@ constexpr auto eval_log(cpp_double_fp_backend& result, const eval_frexp(x2, x, &n2); // Get initial estimate using the self-written, detail math function log. - const double_float_type s(cpp_df_qf_detail::ccmath::log(x2.my_first())); + using local_float_type = typename double_float_type::float_type; + + const local_float_type s { cpp_df_qf_detail::ccmath::log(x2.my_first()) }; double_float_type E { }; - eval_exp(E, s); + eval_exp(E, double_float_type(s)); - // Do one single step of Newton-Raphson iteration. - result = s + ((x2 - E) / E); + // Perform one single step of Newton-Raphson iteration. + // result = s + (x2 - E) / E; - double_float_type xn2 { n2 }; + eval_subtract(result, x2, E); + eval_divide(result, E); + result.add_unchecked_limb(s); - using local_float_type = typename double_float_type::float_type; + double_float_type xn2 { n2 }; eval_multiply(xn2, cpp_df_qf_detail::constant_df_ln_two()); diff --git a/performance/performance_test_df.cpp b/performance/performance_test_df.cpp index 2e3157a88..41a6fd306 100644 --- a/performance/performance_test_df.cpp +++ b/performance/performance_test_df.cpp @@ -226,7 +226,7 @@ void local::test32() static_assert(digits10_for_performance_test >= 32, "Error: Too few digits for performance comparison"); using cpp_bin_float_type = - boost::multiprecision::number, + boost::multiprecision::number, boost::multiprecision::et_off>; test("cpp_bin_float", digits10_for_performance_test); From 50c34d6fde09075254c0ea596f112245457f6c71 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 22 Sep 2025 18:18:39 +0200 Subject: [PATCH 110/114] Update docs yet again --- doc/tutorial_cpp_double_fp_backend.qbk | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/doc/tutorial_cpp_double_fp_backend.qbk b/doc/tutorial_cpp_double_fp_backend.qbk index f3149d03c..4b7fce635 100644 --- a/doc/tutorial_cpp_double_fp_backend.qbk +++ b/doc/tutorial_cpp_double_fp_backend.qbk @@ -23,8 +23,9 @@ } } // namespaces -The `cpp_double_fp_backend` back-end is the sum of two IEEE floating-point numbers -combined to create a type having a composite width rougly twice that as one of its parts. +The `cpp_double_fp_backend` back-end is a relatively simple two-limb backend type. +It is composed of the sum of two IEEE floating-point numbers. +These are combined to create a type having a composite width rougly twice that as one of its parts. The `cpp_double_fp_backend` back-end is used in conjunction with `number` and acts as an entirely C++ header only floating-point number type. @@ -70,8 +71,8 @@ Things you should know when using the `cpp_double_fp_backend` types: * The types can not be used with certain compiler variations of _fast_-_math_. On GCC/clang, for instance, `-ffast-math` can not be used (use either the default or explicitly set `-fno-fast-math`). On MSVC `/fp:fast` can not be used and `/fp:precise` (the default) is mandatory on MSVC compilers. This is because the algorithms, in particular those for addition, subtraction, multiplication, division and square root, rely on precise floating-point rounding. * The composite types are not as precise as their constituents. For information on error-bounds, see Joldes et al. in the references below. * There are `std::numeric_limits` specializations for these types. -* Large parts (but not all) of the `cpp_double_fp_backend` implementation are `constexpr`. Future evolution is anticipated to make this library entirely `constexpr`. -* Conversions to and from string internally use an intermediate `cpp_bin_float` value (which is a bit awkward may be eliminated in future refinements). +* Almost all of the methods of the `cpp_double_fp_backend` implementation are `constexpr`. The sole exception is read-from-string, which is not yet `constexpr`, but may become so in future evolution. +* Conversions to and from string internally use an intermediate `cpp_bin_float` value. This is a bit awkward may be eliminated in future refinements. The `cpp_double_fp_backend` back-end has been inspired by original works and types. These include the historical `doubledouble` and more, as listed below. From d19b4b8b5cbf87f9733b580e8dd149892e6b939d Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Mon, 22 Sep 2025 21:01:12 +0200 Subject: [PATCH 111/114] Increase tolerance suspect sporadic fail --- test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index 5068f968d..13c393a04 100644 --- a/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp +++ b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp @@ -345,7 +345,7 @@ auto do_trials(const std::size_t trial_count) -> void std::size_t count { UINT8_C(0) }; - constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 0x400000 }; + constexpr dbl_float_type tol_dbl { std::numeric_limits::epsilon() * 0x1000000 }; for(const auto& lhs : dbl_float_c_vec) { From 090390edb5723c11ecce4d34e4902cf77c51c650 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 25 Oct 2025 11:25:40 +0200 Subject: [PATCH 112/114] Updated GCC on MinGW needs mbig-obj --- test/Jamfile.v2 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 27862f93b..d3ad81dd0 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -188,7 +188,7 @@ test-suite arithmetic_tests : [ run test_arithmetic_dbg_adptr1m.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_dbg_adptr2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : msvc:-bigobj gcc-mingw:\"-Wa,-mbig-obj\" [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_int_dbg_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_rat_dbg_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpf_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] @@ -198,7 +198,7 @@ test-suite arithmetic_tests : [ run test_arithmetic_mpq_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpz_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : msvc:-bigobj gcc-mingw:\"-Wa,-mbig-obj\" [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_int_logged_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_rat_logged_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] From bf95dbc0f746df6382d2dbd019dfe438452f82bb Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 25 Oct 2025 13:32:14 +0200 Subject: [PATCH 113/114] Review the various big obj spellings --- test/Jamfile.v2 | 164 ++++++++++++++++++++++++------------------------ 1 file changed, 82 insertions(+), 82 deletions(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index d3ad81dd0..670d25a65 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -119,19 +119,19 @@ test-suite arithmetic_tests : [ run test_arithmetic_backend_concept.cpp no_eh_support ] [ compile test_arithmetic_skeleton.cpp ] - [ run test_arithmetic_df.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_dec_float_1.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_dec_float_2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_dec_float_3.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_dec_float_3m.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - - [ run test_arithmetic_cpp_bin_float_1.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_2m.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_3.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_4.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_5.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_bin_float_6.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] [ requires cxx17_if_constexpr ] ] + [ run test_arithmetic_df.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_dec_float_1.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_dec_float_2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_dec_float_3.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_dec_float_3m.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + + [ run test_arithmetic_cpp_bin_float_1.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_2m.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_3.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_4.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_5.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_bin_float_6.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] [ requires cxx17_if_constexpr ] ] [ run test_arithmetic_mpf_50.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpf.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] @@ -148,30 +148,30 @@ test-suite arithmetic_tests : [ run test_arithmetic_tommath_rat.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_tommath_br.cpp /boost/rational//boost_rational $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_1.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_3.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_4.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_5.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_6.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_7.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_8.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_9.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_10.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_11.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_12.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_13.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_14.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_15.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_16.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_17.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_18.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_19.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_20.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_21.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_22.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_23.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_br.cpp no_eh_support /boost/rational//boost_rational : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_1.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_3.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_4.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_5.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_6.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_7.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_8.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_9.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_10.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_11.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_12.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_13.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_14.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_15.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_16.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_17.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_18.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_19.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_20.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_21.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_22.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_23.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_br.cpp no_eh_support /boost/rational//boost_rational : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_ab_1.cpp no_eh_support : : : [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_ab_2.cpp no_eh_support : : : [ check-target-builds ../config//has_float128 : quadmath ] ] @@ -181,32 +181,32 @@ test-suite arithmetic_tests : [ run test_various_edges.cpp no_eh_support ] [ run test_various_edges_more.cpp no_eh_support ] - [ run test_arithmetic_logged_1.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_logged_2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - - [ run test_arithmetic_dbg_adptr1.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_dbg_adptr1m.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_dbg_adptr2.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - - [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : msvc:-bigobj gcc-mingw:\"-Wa,-mbig-obj\" [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_dbg_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_rat_dbg_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpf_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpc_dbg_adptr.cpp mpc mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpc : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpfi_dbg_adptr.cpp mpfi mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpfi : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpfr_dbg_adptr.cpp mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpfr : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpq_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpz_dbg_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - - [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : msvc:-bigobj gcc-mingw:\"-Wa,-mbig-obj\" [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_int_logged_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_rat_logged_adptr.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpc_logged_adptr.cpp mpc mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpc : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpfi_logged_adptr.cpp mpfi mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpfi : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpfr_logged_adptr.cpp mpfr gmp : : : msvc:-bigobj [ check-target-builds ../config//has_mpfr : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpq_logged_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_mpz_logged_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_logged_1.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_logged_2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + + [ run test_arithmetic_dbg_adptr1.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_dbg_adptr1m.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_dbg_adptr2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + + [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_dbg_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_rat_dbg_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpf_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpc_dbg_adptr.cpp mpc mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpc : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpfi_dbg_adptr.cpp mpfi mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpfi : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpfr_dbg_adptr.cpp mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpfr : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpq_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpz_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + + [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_int_logged_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_rat_logged_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpc_logged_adptr.cpp mpc mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpc : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpfi_logged_adptr.cpp mpfi mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpfi : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpfr_logged_adptr.cpp mpfr gmp : : : msvc:/bigobj [ check-target-builds ../config//has_mpfr : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpq_logged_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_mpz_logged_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpfi_50.cpp mpfi mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfi : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] @@ -221,7 +221,7 @@ test-suite arithmetic_tests : [ run test_complex.cpp : : : [ check-target-builds ../config//has_mpc : TEST_MPC mpc mpfr gmp ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_complex.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] TEST_CPP_DOUBLE_FLOAT : test_complex_cpp_double_fp ] [ run test_arithmetic_complex_adaptor.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_complex_adaptor_2.cpp : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_complex_adaptor_2.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_complex128.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_signed_zero.cpp : : : TEST_CPP_BIN_FLOAT [ requires cxx17_if_constexpr ] : test_signed_zero_cpp_bin_float ] @@ -1335,16 +1335,16 @@ test-suite standalone : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_float128 : quadmath : no ] ] [ run standalone_test_arithmetic_complex128.cpp : : : [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_cpp_bin_float.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_cpp_dec_float.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_cpp_int.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_int512.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_cpp_rational.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_cpp_bin_float.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_cpp_dec_float.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_cpp_int.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_int512.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_cpp_rational.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run standalone_test_arithmetic_tommath.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run standalone_test_arithmetic_float_128.cpp quadmath no_eh_support : : : [ check-target-builds ../config//has_float128 : : no ] ] [ run standalone_test_arithmetic_gmp.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:-bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run standalone_test_arithmetic_cpp_double_fp.cpp no_eh_support : : : msvc:-bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run standalone_test_arithmetic_cpp_double_fp.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run standalone_test_miller_rabin.cpp no_eh_support gmp : # command line @@ -1391,7 +1391,7 @@ rule get_specfun_tests_mpfr speed BOOST_ALL_NO_LIB BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_mpfr ] ; @@ -1406,7 +1406,7 @@ rule get_specfun_tests_mpfr speed BOOST_ALL_NO_LIB TEST_PRECISION=$(digits) - msvc:-bigobj + msvc:/bigobj [ check-target-builds ../config//has_mpfr : TEST_MPFR gmp mpfr : no ] [ check-target-builds ../config//has_float128 : quadmath ] /boost/math//testing @@ -1433,7 +1433,7 @@ rule get_specfun_tests_gmp speed TEST_MPF_50 BOOST_ALL_NO_LIB - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_mpf ] ; @@ -1448,7 +1448,7 @@ rule get_specfun_tests_gmp speed BOOST_ALL_NO_LIB TEST_PRECISION=$(digits) - msvc:-bigobj + msvc:/bigobj [ check-target-builds ../config//has_gmp : TEST_MPF gmp : no ] [ check-target-builds ../config//has_float128 : quadmath ] /boost/math//testing @@ -1472,7 +1472,7 @@ rule get_specfun_tests_cpp_dec_float [ check-target-builds ../config//has_float128 : quadmath ] TEST_CPP_DEC_FLOAT BOOST_ALL_NO_LIB - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_cpp_dec_float ] ; @@ -1487,7 +1487,7 @@ rule get_specfun_tests_cpp_dec_float speed BOOST_ALL_NO_LIB TEST_PRECISION=$(digits) - msvc:-bigobj + msvc:/bigobj TEST_CPP_DEC_FLOAT /boost/math//testing release @@ -1508,7 +1508,7 @@ rule get_specfun_tests_cpp_bin_float : # requirements TEST_CPP_BIN_FLOAT BOOST_ALL_NO_LIB - msvc:-bigobj + msvc:/bigobj /boost/math//testing release [ check-target-builds ../config//has_float128 : quadmath ] @@ -1524,7 +1524,7 @@ rule get_specfun_tests_cpp_bin_float speed BOOST_ALL_NO_LIB TEST_PRECISION=$(digits) - msvc:-bigobj + msvc:/bigobj TEST_CPP_BIN_FLOAT [ check-target-builds ../config//has_float128 : quadmath ] /boost/math//testing @@ -1551,7 +1551,7 @@ rule get_specfun_tests_float128 TEST_FLOAT128 BOOST_ALL_NO_LIB BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_float128 ] ; @@ -1572,7 +1572,7 @@ rule get_specfun_tests_cpp_double_double [ check-target-builds ../config//has_float128 : quadmath ] TEST_CPP_DOUBLE_FLOAT BOOST_ALL_NO_LIB - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_cpp_double_double ] ; @@ -1597,7 +1597,7 @@ rule get_specfun_tests_intel_quad TEST_FLOAT128 BOOST_ALL_NO_LIB BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE - msvc:-bigobj + msvc:/bigobj /boost/math//testing release : $(source:B)_intel_quad ] ; From 0a1a6d72a69958da7c3b7dd2e308be6912864702 Mon Sep 17 00:00:00 2001 From: ckormanyos Date: Sat, 25 Oct 2025 14:18:10 +0200 Subject: [PATCH 114/114] Retry big object on MinGW --- test/Jamfile.v2 | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 670d25a65..fe0d61c59 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -59,6 +59,7 @@ project : requirements msvc:static msvc:all msvc:/fp\:precise + gcc,windows:"-Wa,-mbig-obj" intel-win:static intel-win:static clang-win:static # Clang-win does not generate .dlls. @@ -188,7 +189,7 @@ test-suite arithmetic_tests : [ run test_arithmetic_dbg_adptr1m.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_dbg_adptr2.cpp no_eh_support : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj off msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_int_dbg_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_rat_dbg_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpf_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] @@ -198,7 +199,7 @@ test-suite arithmetic_tests : [ run test_arithmetic_mpq_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpz_dbg_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ] - [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] + [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : gcc-mingw:-Wa,-mbig-obj off msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_int_logged_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_cpp_rat_logged_adptr.cpp : : : msvc:/bigobj [ check-target-builds ../config//has_float128 : quadmath ] ] [ run test_arithmetic_mpf_logged_adptr.cpp gmp : : : msvc:/bigobj [ check-target-builds ../config//has_gmp : : no ] [ check-target-builds ../config//has_float128 : quadmath ] ]