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 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/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/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/introduction.qbk b/doc/introduction.qbk index 4eb3b5500..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,9 +206,9 @@ 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 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. @@ -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/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/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..459bb988b 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,17 +40,17 @@ 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`]] [[`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 `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`]] [[`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..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; @@ -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 `?:`. @@ -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; @@ -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 9011dc25b..b7798fe1c 100644 --- a/doc/tutorial.qbk +++ b/doc/tutorial.qbk @@ -13,8 +13,11 @@ 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]. [include tutorial_integer.qbk] [include tutorial_floats.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_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_double_fp_backend.qbk b/doc/tutorial_cpp_double_fp_backend.qbk index e8ea09882..4b7fce635 100644 --- a/doc/tutorial_cpp_double_fp_backend.qbk +++ b/doc/tutorial_cpp_double_fp_backend.qbk @@ -23,27 +23,29 @@ } } // 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. +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. 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. @@ -55,8 +57,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 @@ -66,19 +68,19 @@ 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 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 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]. * 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/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 c9114a6e9..96758091b 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] @@ -46,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 5c4f42292..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] @@ -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/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 49b26de95..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.] @@ -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] 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_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_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 2f592cad6..e91fc0d9f 100644 --- a/doc/tutorial_rational.qbk +++ b/doc/tutorial_rational.qbk @@ -18,13 +18,12 @@ 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] [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] 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 6e066a4bc..e9489eced 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!!] 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_complex_examples.cpp b/example/cpp_complex_examples.cpp index 7d00cc738..2e1166293 100644 --- a/example/cpp_complex_examples.cpp +++ b/example/cpp_complex_examples.cpp @@ -1,10 +1,13 @@ /////////////////////////////////////////////////////////////// -// 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 -/*`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 @@ -18,103 +21,86 @@ 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; + 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 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"; - 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; + 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() { - std::cout << "First, some operations we usually perform with std::complex:\n"; + 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"; - complex_number_examples(); - return 0; -} -//] + std::cout << "\nNow the same operations performed with quad precision complex numbers:\n"; + complex_number_examples(); +}//] /* //[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) +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: -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) +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) //] */ 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/exercise_threading_log_agm.cpp b/example/exercise_threading_log_agm.cpp index 10ce93004..0a9625b54 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,73 +25,80 @@ // 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: 14.7s // // 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 #include #include +#include #include #include #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 +119,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 +317,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 +349,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 +359,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; @@ -371,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; } @@ -384,7 +396,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 +416,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; @@ -430,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; } @@ -442,31 +459,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/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: 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_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/include/boost/multiprecision/cpp_dec_float.hpp b/include/boost/multiprecision/cpp_dec_float.hpp index c9b958c06..79bf0a5ad 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 @@ -72,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. @@ -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. @@ -163,33 +157,20 @@ 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 - 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,43 +194,35 @@ 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; } - 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 { @@ -427,7 +395,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() @@ -446,7 +413,6 @@ class cpp_dec_float return ((fpclass == cpp_dec_float_finite) && (data[0u] == 0u)); } - bool isone() const; bool isint() const; bool isneg() const { return neg; } @@ -506,24 +472,57 @@ class cpp_dec_float exponent_type order() const { - const bool bo_order_is_zero = ((!(isfinite)()) || (data[0] == static_cast(0u))); + const bool + bo_order_is_zero + { + ((!(isfinite)()) || (data[0] == static_cast(0u))) + }; + + return (bo_order_is_zero ? static_cast(0) + : static_cast(exp + limb_order(data[static_cast(UINT8_C(0))]))); + } + + #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; @@ -531,42 +530,35 @@ 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)); + return prefix; } - #ifndef BOOST_MP_STANDALONE - template - void serialize(Archive& ar, const unsigned int /*version*/) + bool isone() const { - 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); + bool b_neg; + + const bool result_one_is_ok = is_one_or_minus_one(&b_neg); + + return (result_one_is_ok && (!b_neg)); } - #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')); } + bool is_one_or_minus_one(bool* p_sign) const; void from_unsigned_long_long(const unsigned long long u); @@ -1178,7 +1170,7 @@ cpp_dec_float& cpp_dec_float(n); @@ -1218,38 +1210,33 @@ cpp_dec_float& 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; - } - if ((isnan)()) - { return *this; } + // Handle the special cases of inf, NaN, and +1 or -1. + if ((isinf)()) { return *this = zero(); } - if (isone()) + bool b_neg; + + if ((isnan)() || is_one_or_minus_one(&b_neg)) { - if (b_neg) - negate(); return *this; } - // Save the original *this. + // Compute the inverse of *this. + + neg = false; + + // Save the original (absolute value of) *this. cpp_dec_float x(*this); // Generate the initial estimate using division. @@ -1259,7 +1246,11 @@ cpp_dec_float& cpp_dec_float(1.0 / dd, -ne)); // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration @@ -1294,7 +1285,7 @@ cpp_dec_float& cpp_dec_float& cpp_dec_float(sqd, static_cast(ne / static_cast(2))); @@ -1423,8 +1417,7 @@ int 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()) { @@ -1459,23 +1452,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()); + + const bool result_one_is_ok = (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; } } @@ -1517,49 +1517,43 @@ 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); + const local_exponent_type my_order_limb0 { limb_order(data.front()) }; - if (test == static_cast(0u)) - { - break; - } + exponent = static_cast(exp + my_order_limb0); - p10 *= static_cast(10u); - ++exponent; - } + // Extract into the mantissa the first limb, extracted as a double. - // 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; + mantissa = ((!neg) ? static_cast(data.front()) : -static_cast(data.front())); - // 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)); + int digit_counter { static_cast(my_order_limb0) }; - // Extract into the mantissa the first limb, extracted as a double. - mantissa = static_cast(data[0]); - double scale = 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. + mantissa /= p10; // Extract the rest of the mantissa piecewise from the limbs. - for (std::size_t i = 1u; i < max_elem_extract_count; i++) - { - scale /= static_cast(cpp_dec_float_elem_mask); - mantissa += (static_cast(data[i]) * scale); - } + // This loop does not round. For finite values, the absolute + // value of the mantissa is scaled and between 1 and 10. - mantissa /= static_cast(p10); + auto itr_data = data.cbegin() + static_cast(UINT8_C(1)); - if (neg) + while ((itr_data != data.cend()) && (digit_counter <= std::numeric_limits::max_digits10)) { - mantissa = -mantissa; + p10 *= static_cast(cpp_dec_float_elem_mask); + + mantissa += static_cast(static_cast(*itr_data++) / p10); + + digit_counter += static_cast(cpp_dec_float_elem_digits10); } } @@ -1577,12 +1571,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(); @@ -1595,17 +1590,18 @@ 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 ss; - ss.imbue(std::locale::classic()); + std::stringstream strm { }; - ss << str(std::numeric_limits::digits10 + (2 + 1), std::ios_base::scientific); + strm.imbue(std::locale::classic()); + + strm << str(std::numeric_limits::max_digits10, std::ios_base::scientific); double d; - ss >> d; + strm >> d; return d; } @@ -1646,13 +1642,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::max_digits10, std::ios_base::scientific); long double ld; - ss >> ld; + strm >> ld; return ld; } @@ -1923,9 +1919,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; @@ -1936,22 +1932,31 @@ 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. - 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; @@ -1962,40 +1967,42 @@ 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'); - have_leading_zeros = true; + my_str.insert(static_cast(0), std::string::size_type(number_of_digits), '0'); + have_leading_zeros = true; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. } } if (number_of_digits < 0) { - str = "0"; + my_str = "0"; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. 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) + // 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]) @@ -2011,45 +2018,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"; // LCOV_EXCL_LINE This causes a false negative on lcov coverage test. ++my_exp; } } @@ -2060,20 +2067,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 @@ -2084,7 +2091,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 @@ -2095,61 +2102,64 @@ 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) - 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)))); + 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")); // LCOV_EXCL_LINE + 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.empty()) { - 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) - { - *this = this->inf(); - this->negate(); - } - else - *this = this->inf(); + const bool tmp_neg { neg }; + + *this = this->inf(); + + neg = tmp_neg; + 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. @@ -2158,7 +2168,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); } } @@ -2169,32 +2179,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) - 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) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + 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")); // 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")); // LCOV_EXCL_LINE // 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; @@ -2204,31 +2215,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) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with non-numeric content")); + 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")); // LCOV_EXCL_LINE // 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. @@ -2243,29 +2254,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)) @@ -2274,25 +2285,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")); + 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(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)) @@ -2301,16 +2312,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. @@ -2322,19 +2333,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) @@ -2345,36 +2356,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 @@ -2394,72 +2411,82 @@ 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) +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. - 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)); - if (mantissa_is_iszero) - { - std::fill(data.begin(), data.end(), static_cast(0u)); - return; - } + constexpr double + dbl_min_check + { + static_cast + ( + (std::numeric_limits::min)() * (1.0 + std::numeric_limits::epsilon()) + ) + }; - 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_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 }; - std::int32_t shift = static_cast(e % static_cast(cpp_dec_float_elem_digits10)); + // 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 (static_cast(shift-- % cpp_dec_float_elem_digits10) != static_cast(0)) - { - d *= 10.0; - --e; - } + while (d_mant < 1.0) + { + d_mant *= 10.0; + --exp10_val; + } - exp = e; - neg = b_neg; + std::int32_t shift = static_cast(exp10_val % static_cast(cpp_dec_float_elem_digits10)); - std::fill(data.begin(), data.end(), static_cast(0u)); + while (static_cast(shift-- % cpp_dec_float_elem_digits10) != static_cast(0)) + { + d_mant *= 10.0; + --exp10_val; + } + + 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. 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; @@ -2527,26 +2554,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 @@ -3154,7 +3208,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) @@ -3162,20 +3216,40 @@ 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) +{ + result = cpp_dec_float(a) += 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) +{ + result = cpp_dec_float(a) -= 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) +{ + result = cpp_dec_float(a) *= 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) +{ + result = cpp_dec_float(a) /= b; +} template inline void eval_add(cpp_dec_float& result, const unsigned long long& o) @@ -3406,34 +3480,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)())) - BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Exponent value is out of range."))); + 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."))); // LCOV_EXCL_LINE + } 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 This causes a false negative on lcov coverage test. 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)()) @@ -3442,12 +3532,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; @@ -3458,55 +3552,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)) - 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)) - 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::max)() - e2)) + 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.")); // LCOV_EXCL_LINE 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.div_unsigned_long_long(2ULL); ++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.mul_unsigned_long_long(2ULL); --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)())) - BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int")); + + 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")); // LCOV_EXCL_LINE + } + *e = static_cast(t); } @@ -3518,7 +3622,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/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..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 @@ -32,6 +30,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(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 + { + 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 { @@ -42,12 +57,14 @@ struct pair 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 } { } + // 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 } { } - constexpr auto operator=(const pair& other) -> pair& + constexpr auto operator=(const pair& other) noexcept -> pair& { if (this != &other) { @@ -93,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 @@ -155,15 +172,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_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_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_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..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 @@ -15,43 +15,56 @@ 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); -} - -} // Namespace detail - -template -constexpr auto ldexp(Real arg, int expval) -> Real -{ - return detail::ldexp_impl(arg, expval); -} + while(expval > 16) + { + arg *= two_pow_16_plus; + expval -= 16; + } -namespace unsafe { + while(expval < -16) + { + arg /= two_pow_16_plus; + expval += 16; + } -template -constexpr auto ldexp(Real arg, int exp) noexcept -> Real -{ - while(exp > 0) + while(expval > 0) { arg *= 2; - --exp; + --expval; } - while(exp < 0) + + while(expval < 0) { arg /= 2; - ++exp; + ++expval; } return arg; } +// LCOV_EXCL_STOP + +} // Namespace detail + +template +constexpr auto ldexp(Real arg, int expval) noexcept -> Real +{ + if (BOOST_MP_IS_CONST_EVALUATED(arg)) + { + return detail::ldexp_impl(arg, expval); // LCOV_EXCL_LINE + } + else + { + using std::ldexp; -} // namespace unsafe + return ldexp(arg, expval); + } +} } } } } } // namespace boost::multiprecision::backends::cpp_df_qf_detail::ccmath 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..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 @@ -8,28 +8,163 @@ #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(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] +// 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 +{ + // 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 { - // Default to the regular log function. - using std::log; + // 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 log(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 { }; + + // 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)) + { + x2 /= 2; + + ++n2; + } + + // 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) }; + + // Perform one single step of Newton-Raphson iteration + // and scale the result back up. + + return (s + ((x2 - E) / E)) + Real { static_cast(n2) * constant_ln_two() }; +} +// 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 381570b91..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 @@ -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,17 +33,25 @@ 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 - } } } } } // 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_df_qf/cpp_df_qf_detail_constants.hpp b/include/boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_constants.hpp index fed468273..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] @@ -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 4e8245f18..be199ae63 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,9 +137,8 @@ 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 -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; @@ -163,9 +162,15 @@ 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. +// 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 @@ -178,11 +183,11 @@ 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) - }, "Error: float_type does not fulfil the backend requirements of cpp_double_fp_backend" + ((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" ); using rep_type = cpp_df_qf_detail::pair; @@ -244,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 && (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 - flt_mask - { - static_cast - ( - static_cast - ( - static_cast(UINT8_C(1)) << static_cast(std::numeric_limits::digits) - ) - - static_cast(UINT8_C(1)) - ) - }; - - data.second = static_cast(0.0F); - data.first = static_cast(u & flt_mask); - - int u_index { 1 }; - - while (u > static_cast(UINT8_C(0))) + if (u > cpp_df_qf_detail::float_mask()) { - u >>= static_cast(std::numeric_limits::digits); - - const float_type - xhi + local_unsigned_integral_type + local_flt_mask { - static_cast(u & flt_mask) - * cpp_df_qf_detail::pow2_maker::value(std::numeric_limits::digits * u_index) + cpp_df_qf_detail::float_mask() }; - eval_add(*this, cpp_double_fp_backend(xhi)); + 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) + { + local_flt_mask <<= static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits); - ++u_index; + add_unchecked_limb(static_cast(u & local_flt_mask)); + } } } @@ -315,7 +303,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; @@ -340,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. @@ -385,45 +373,32 @@ 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; } - 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; - } - }; + #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 std::size_t result { UINT8_C(0) }; - static_cast(hash_one(result, data.first)); - static_cast(hash_one(result, data.second)); + 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; } @@ -434,7 +409,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 { @@ -448,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); } } } @@ -514,15 +492,7 @@ class cpp_double_fp_backend } } - const float_type xlo { 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); + add_unchecked(v); return *this; } @@ -578,11 +548,24 @@ 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) }; + 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); @@ -716,7 +699,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 }; @@ -742,33 +726,27 @@ 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 }; 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); @@ -894,19 +872,18 @@ class cpp_double_fp_backend } } + // 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) - { - 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. - 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); } @@ -933,35 +910,29 @@ 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. - 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::unsafe::ldexp + return + cpp_double_fp_backend + ( + 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::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) }; - - 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" - ); - - return my_value_max_constexpr; + ); } static constexpr auto my_value_min() noexcept -> cpp_double_fp_backend @@ -969,68 +940,128 @@ 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 - { - cpp_df_qf_detail::ccmath::unsafe::ldexp + return + cpp_double_fp_backend + ( + 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 + ) ) - }; - - 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" - ); - - return my_value_min_constexpr; + ); } static constexpr auto my_value_eps() noexcept -> 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 }) - }; - - 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" - ); - - return my_value_eps_constexpr; + return + cpp_double_fp_backend + ( + float_type(cpp_df_qf_detail::ccmath::ldexp(float_type { 1 }, int { 3 - my_digits })) + ); } 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 } - private: + static constexpr auto my_value_logmax() -> cpp_double_fp_backend + { + 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 + 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 + ) + ) + ) + ); + } + + 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>; - 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* p_str) -> 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); + + if (cpp_df_qf_detail::ccmath::isinf(data.first)) + { + // Handle overflow. + const bool b_neg { (data.first < float_type { 0.0F }) }; - auto rd_string(const char* pstr) -> bool; + *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); + } constexpr auto mul_unchecked(const cpp_double_fp_backend& v) -> void { // 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 }; @@ -1083,19 +1114,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,111 +1154,147 @@ 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* p_str) -> bool { - using local_double_fp_type = cpp_double_fp_backend; + // Use an intermediate cpp_bin_float backend type for reading string input. + + cpp_bin_float_read_write_backend_type f_bin { }; - cpp_bin_float_read_write_type f_bin { pstr }; + f_bin = p_str; - const auto fpc = fpclassify(f_bin); + const int fpc { eval_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) { static_cast(operator=(local_double_fp_type::my_value_nan())); + + return true; } - else - { - const bool b_neg { (signbit(f_bin) == 1) }; - if (b_neg) { f_bin = -f_bin; } + const bool b_neg { (eval_signbit(f_bin) == 1) }; - const int - expval_from_f_bin + if (b_neg) { f_bin.negate(); } + + const int + expval_from_f_bin + { + [&f_bin]() { - [&f_bin]() - { - int expval; + int expval { }; - frexp(f_bin, &expval); + cpp_bin_float_read_write_backend_type dummy { }; - return expval; - }() - }; + eval_frexp(dummy, f_bin, &expval); - const auto is_zero_or_subnormal = - ( - (fpc == FP_ZERO) - || (expval_from_f_bin < static_cast(local_double_fp_type::my_min_exponent)) - ); + return expval; + }() + }; + + 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 }; + + return true; + } + + float_type flt_inf_check_first { }; + + eval_convert_to(&flt_inf_check_first, f_bin); + + bool is_definitely_inf { ((fpc == FP_INFINITE) || cpp_df_qf_detail::ccmath::isinf(flt_inf_check_first)) }; - if (is_zero_or_subnormal) + if ((!is_definitely_inf) && (flt_inf_check_first > my_value_max().my_first())) + { + 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); + + is_definitely_inf = eval_gt(local_double_fp_type(flt_inf_check_first, flt_inf_check_second), my_value_max()); + }; + + 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(); } - else - { - const auto is_definitely_inf = (f_bin > (::std::numeric_limits::max)()); - if (is_definitely_inf) - { - static_cast(operator=(local_double_fp_type::my_value_inf())); + return true; + } - if (b_neg) { negate(); } - } - else - { - data.first = float_type { 0.0F }; - data.second = float_type { 0.0F }; + // The input string is normal. We will now extract its value. - using local_builtin_float_type = typename std::conditional<(sizeof(float_type) <= sizeof(double)), double, float_type>::type; + data.first = float_type { 0.0F }; + data.second = float_type { 0.0F }; - constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; + // Handle small input values. Scale (and re-scale them below) if possible. - 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) - ); + constexpr int pow2_scaling_for_small_input { cpp_df_qf_detail::ccmath::numeric_limits::digits }; - if (has_pow2_scaling_for_small_input) - { - f_bin = ldexp(f_bin, 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)) + }; - constexpr auto dig_lim = - 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 - ); + if (has_pow2_scaling_for_small_input) + { + eval_ldexp(f_bin, f_bin, pow2_scaling_for_small_input); + } - for(auto i = static_cast(UINT8_C(0)); - i < dig_lim; - i = static_cast(i + static_cast(cpp_df_qf_detail::ccmath::numeric_limits::digits))) - { - const local_builtin_float_type f { static_cast(f_bin) }; + 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 + ) + }; - f_bin -= cpp_bin_float_read_write_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_add(*this, local_double_fp_type { f }); - } + eval_convert_to(&flt_part, f_bin); - if (has_pow2_scaling_for_small_input) - { - eval_ldexp(*this, *this, -pow2_scaling_for_small_input); - } + eval_subtract(f_bin, cpp_bin_float_read_write_backend_type(flt_part)); - if (b_neg) { negate(); } - } - } + eval_add(*this, local_double_fp_type { flt_part }); } + if (has_pow2_scaling_for_small_input) + { + eval_ldexp(*this, *this, -pow2_scaling_for_small_input); + } + + if (b_neg) { negate(); } + return true; } @@ -1444,7 +1518,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 @@ -1473,7 +1547,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) { @@ -1481,10 +1554,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)) @@ -1497,6 +1566,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) { @@ -1507,6 +1580,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) { @@ -1516,12 +1593,31 @@ constexpr auto eval_pow(cpp_double_fp_backend& result, const { if (fpc_a == FP_INFINITE) { - 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 - ); + 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 { @@ -1541,7 +1637,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) }; @@ -1613,19 +1709,23 @@ 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 { + using double_float_type = cpp_double_fp_backend; + + constexpr double_float_type one { 1 }; + const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + const bool b_neg { x.isneg_unchecked() }; if (fpc == FP_ZERO) { - result = double_float_type { 1.0F }; + result = one; } else if (fpc != FP_NORMAL) { 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) { @@ -1637,51 +1737,27 @@ 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(); } 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 { @@ -1689,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 @@ -1724,12 +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))))); - constexpr double_float_type one { 1 }; - - result = one + (top / bot); + eval_divide(result, bot); + result.add_unchecked_limb(local_float_type { 1.0F }); // Rescale the result. if (b_scale) @@ -1745,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 = double_float_type(1U) / result; + eval_divide(result, one, result); } } } @@ -1761,19 +1836,23 @@ 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 { + using double_float_type = cpp_double_fp_backend; + + constexpr double_float_type one { 1 }; + const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + const bool b_neg { x.isneg_unchecked() }; if (fpc == FP_ZERO) { - result = double_float_type(1); + result = one; } else if (fpc != FP_NORMAL) { 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) { @@ -1785,51 +1864,27 @@ 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(); } 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 { @@ -1837,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 @@ -1872,12 +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)))))))); - constexpr double_float_type one { 1 }; - - result = one + (top / bot); + eval_divide(result, bot); + result.add_unchecked_limb(local_float_type { 1.0F }); // Rescale the result. if (b_scale) @@ -1895,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 = double_float_type(1U) / result; + eval_divide(result, one, result); } } } @@ -1911,19 +1965,23 @@ 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 { + using double_float_type = cpp_double_fp_backend; + + constexpr double_float_type one { 1 }; + const int fpc { eval_fpclassify(x) }; - using double_float_type = cpp_double_fp_backend; + const bool b_neg { x.isneg_unchecked() }; if (fpc == FP_ZERO) { - result = double_float_type(1); + result = one; } else if (fpc != FP_NORMAL) { 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) { @@ -1935,51 +1993,27 @@ 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(); } 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 { @@ -1987,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 @@ -2005,28 +2039,30 @@ 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 = 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; - x_pow_n_div_n_fact /= typename double_float_type::float_type(n); + eval_multiply(x_pow_n_div_n_fact, xh); + + 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 - 4))) + 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. @@ -2045,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 = double_float_type(1U) / result; + eval_divide(result, one, result); } } } @@ -2102,19 +2138,23 @@ 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. + 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()); @@ -2259,7 +2299,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 { @@ -2387,7 +2427,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)); @@ -2466,7 +2506,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(); } @@ -2475,11 +2515,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 @@ -2616,16 +2656,20 @@ struct precision; - using digits_2 = digits2; + using digits2_type = digits2; + + 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< - ((digits_2::value <= precision_type::value) || (precision_type::value <= 0)), - digits_2, // Default case: Full precision for RealType. - precision_type>::type; // User customized precision. + typename std::conditional::type; // Here we find (and use) user-customized precision. }; } } } // namespace boost::math::policies 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); 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; diff --git a/include/boost/multiprecision/detail/default_ops.hpp b/include/boost/multiprecision/detail/default_ops.hpp index d66fe4a16..87ada6e4d 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,7 @@ BOOST_MP_CXX14_CONSTEXPR void eval_karatsuba_sqrt(Backend& result, const Backend result = s; } +#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION template void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) { @@ -1860,6 +1861,7 @@ void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x) --g; } while (g >= 0); } +#endif // !BOOST_MP_NO_CONSTEXPR_DETECTION template BOOST_MP_CXX14_CONSTEXPR void eval_integer_sqrt(Backend& result, Backend& r, const Backend& x) @@ -1868,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; @@ -2623,7 +2626,7 @@ 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); return erf(value_type(arg)); } template @@ -3867,7 +3870,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/include/boost/multiprecision/detail/functions/constants.hpp b/include/boost/multiprecision/detail/functions/constants.hpp index e88a49ee4..13f5177ec 100644 --- a/include/boost/multiprecision/detail/functions/constants.hpp +++ b/include/boost/multiprecision/detail/functions/constants.hpp @@ -10,7 +10,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: @@ -249,8 +249,9 @@ const T& get_constant_e() template const T& get_constant_pi() { - static BOOST_MP_THREAD_LOCAL T result; + 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); diff --git a/include/boost/multiprecision/detail/functions/pow.hpp b/include/boost/multiprecision/detail/functions/pow.hpp index 481c7e4e9..9cf265fb1 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: @@ -488,8 +491,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,27 +500,29 @@ 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) + + if (eval_is_zero(a)) { result = si_type(1); return; } - int type = eval_fpclassify(x); + const int fpc_x { eval_fpclassify(x) }; + const int fpc_a { eval_fpclassify(a) }; - switch (type) + switch (fpc_x) { case FP_ZERO: - switch (eval_fpclassify(a)) + switch (fpc_a) { - case FP_ZERO: - result = si_type(1); - break; case FP_NAN: result = a; break; @@ -555,7 +558,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.. } @@ -580,12 +583,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) { @@ -643,7 +641,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); } @@ -659,9 +657,23 @@ 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) { - 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(); // LCOV_EXCL_LINE There is no NaN for this number type. + } } else BOOST_IF_CONSTEXPR (std::numeric_limits >::has_quiet_NaN) { @@ -670,7 +682,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; } @@ -737,7 +749,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) { @@ -754,7 +766,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/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/performance/performance_test_df.cpp b/performance/performance_test_df.cpp index 16a8b8712..41a6fd306 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: @@ -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); diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 8bb53c7c0..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. @@ -119,19 +120,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_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_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 +149,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 +182,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 [ 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 [ 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 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 ] ] + [ 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 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 ] ] + [ 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 ] ] @@ -219,9 +220,9 @@ 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_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 ] @@ -512,6 +513,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 : : : [ 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 @@ -1257,6 +1260,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 ] ] @@ -1275,6 +1279,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 : ] @@ -1331,16 +1336,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 @@ -1387,7 +1392,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 ] ; @@ -1402,7 +1407,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 @@ -1429,7 +1434,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 ] ; @@ -1444,7 +1449,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 @@ -1468,7 +1473,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 ] ; @@ -1483,7 +1488,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 @@ -1504,7 +1509,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 ] @@ -1520,7 +1525,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 @@ -1547,7 +1552,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 ] ; @@ -1568,7 +1573,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 ] ; @@ -1593,7 +1598,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 ] ; diff --git a/test/git_issue_167.cpp b/test/git_issue_167.cpp index ddfc91fac..469f4d35f 100644 --- a/test/git_issue_167.cpp +++ b/test/git_issue_167.cpp @@ -1,23 +1,65 @@ /////////////////////////////////////////////////////////////////////////////// -// 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::locale::global(std::locale("en-US")); - boost::multiprecision::cpp_dec_float_50 d("1234.56"); - std::string s = d.str(); + 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; + + // Test a string with a decimal point. + local_dec_float_type d_first("1234.56"); + str = d_first.str(); + BOOST_CHECK(str == "1234.56"); + + #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 + // 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"); - BOOST_CHECK_EQUAL(s, "1234.56"); + std::cout << "A local locale was set: " << p_str_loc << std::endl; + + { + std::stringstream strm { }; + + strm << p_str_loc; + + // Check the new local locale. + BOOST_CHECK(strm.str().find("UTF") != std::string::npos); + } + #endif + + 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 == "123.789"); return boost::report_errors(); } - - 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); } diff --git a/test/git_issue_734.cpp b/test/git_issue_734.cpp new file mode 100644 index 000000000..77eb1be90 --- /dev/null +++ b/test/git_issue_734.cpp @@ -0,0 +1,86 @@ +// 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 +#include + +namespace local { + +template +auto my_stringify_via_top_level_number(const std::streamsize strm_size) -> std::string +{ + 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(static_cast(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; + + #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(static_cast(strm_size)) << std::fixed; + + return x.str(strm_size, strm.flags()); +} + +template +auto test() -> void +{ + 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 + +auto main() -> int +{ + local::test>(); + local::test>(); + BOOST_IF_CONSTEXPR(std::numeric_limits::digits >= 53) + { + local::test>(); + } + + return boost::report_errors(); +} diff --git a/test/math/test_bessel_j.cpp b/test/math/test_bessel_j.cpp index 7a57d988e..d5484832a 100644 --- a/test/math/test_bessel_j.cpp +++ b/test/math/test_bessel_j.cpp @@ -62,7 +62,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 +84,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.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_arithmetic_df.cpp b/test/test_arithmetic_df.cpp index 85b4e0f58..add807815 100644 --- a/test/test_arithmetic_df.cpp +++ b/test/test_arithmetic_df.cpp @@ -13,24 +13,50 @@ #include "test_arithmetic.hpp" +template +auto test_constexpr_ness() noexcept -> void +{ + using local_float_type = FloatType; + + constexpr local_float_type one { 1 }; + + static_assert(one == 1, "Error: constexpr local_float_type construction failed"); + + BOOST_CHECK(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)) }; + 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() { - 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(); } 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_complex.cpp b/test/test_complex.cpp index 86b7cfaa4..1d045ecd7 100644 --- a/test/test_complex.cpp +++ b/test/test_complex.cpp @@ -9,12 +9,20 @@ // "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 +#include +#include +#include + #ifdef TEST_MPC #include #endif -#include -#include #ifdef BOOST_HAS_FLOAT128 #include #endif @@ -22,33 +30,67 @@ #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 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. @@ -77,32 +119,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); @@ -157,7 +199,73 @@ 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() }; + + auto dis = + std::uniform_real_distribution + { + static_cast(1.1F), + static_cast(1.5E10F) + }; + + 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 real_type real_val = around_three_base * dis(gen); + + const complex_type cpx(real_val); + + { + const complex_type sqrt_cpx = sqrt(cpx); + 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); + } + + { + const complex_type exp_cpx = exp(cpx); + 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); + } + } + + 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 @@ -167,21 +275,45 @@ 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 defined(TEST_CPP_DOUBLE_FLOAT) { - local::test>, boost::multiprecision::et_off>>(); - local::test>, boost::multiprecision::et_off>>(); + 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_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(); + } + +#ifdef TEST_CPP_DOUBLE_FLOAT + { + 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 return boost::report_errors(); } + +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(); -} 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_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_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/performance/performance_test_df_local.cpp b/test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp similarity index 62% rename from performance/performance_test_df_local.cpp rename to test/test_cpp_double_float_bessel_versus_bin_and_dec.cpp index c833c0b41..13c393a04 100644 --- a/performance/performance_test_df_local.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 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 @@ -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,48 +132,37 @@ 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.at(std::string::size_type { UINT8_C(0) }) = static_cast(dist_dig(eng_dig)); - std::generate(str_x.begin(), + // Insert a decimal point. + 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(), []() // 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; +} // LCOV_EXCL_LINE template auto is_close_fraction(const NumericType& a, @@ -217,21 +187,32 @@ 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 { }; + static std::size_t total_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,12 +220,14 @@ 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 { 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 { @@ -252,33 +235,48 @@ 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()); // 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 val; + return (next_positive ? val : -val); // LCOV_EXCL_LINE + } + // LCOV_EXCL_STOP } }; - 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.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.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) }; - 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.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 } 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 +287,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.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) }; @@ -298,17 +296,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.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) }; + my_stopwatch.reset(); + + for(std::size_t count { UINT8_C(0) }; count < trials; ++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) }; + #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.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) }; @@ -318,37 +325,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() * 0x1000000 }; 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(0x4000) }; + 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_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_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 "test.hpp" +#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 @@ -67,6 +65,13 @@ #include #endif +#include +#include +#include + +template auto my_zero() -> FloatType&; +template auto my_one() -> FloatType&; + template void test() { @@ -74,9 +79,11 @@ 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 = + using table_data_array_type = std::array; + + static const table_data_array_type table_data = {{ "1.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.47747587596218770242116751705184563668845029215054154915126374673142219159548534317576897266130328412495991561490384353e76", @@ -131,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) @@ -158,11 +170,14 @@ 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; - 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")}}, @@ -174,39 +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 = 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) { - if (std::numeric_limits::has_infinity) + static_cast(i); + + BOOST_IF_CONSTEXPR (std::numeric_limits::has_infinity) { BOOST_CHECK_EQUAL(exp(bug_case), 0); } @@ -216,20 +275,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)()); } } @@ -287,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_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. } } } 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_pow.cpp b/test/test_pow.cpp index d2897808d..18334aa36 100644 --- a/test/test_pow.cpp +++ b/test/test_pow.cpp @@ -14,6 +14,8 @@ #endif #include +#include +#include #include #include @@ -23,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 @@ -38,8 +41,6 @@ #endif #include // Note: include this AFTER the test-backends are defined -#include -#include #if defined(TEST_MPF_50) #include @@ -66,13 +67,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,6 +129,110 @@ namespace local { } // namespace local +#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. + +// 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() +{ + 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())); + + 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 neg_inf = T(-std::numeric_limits::infinity() * 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_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); + } + } +} + +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 = 0U; + + const T x_val(T(789U) / 1000); + + const T local_tol { std::numeric_limits::epsilon() / 8 }; + + T small_a = pow(T(10), -12); + + for (std::size_t k { UINT8_C(0) }; k < std::tuple_size::value; ++k) + { + const 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) }; + + const T rel = closeness / local_tol; + + unsigned err = rel.template convert_to(); + + if (err > max_err) + { + max_err = err; + } + } + + std::cout << "Max error data having small a: " << max_err << std::endl; + + 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) || defined(TEST_FLOAT128)) + template void test() { @@ -139,7 +245,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])); @@ -157,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 < 40000U); +#else + BOOST_TEST(max_err < 8000U); +#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); @@ -170,8 +283,8 @@ 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)) - // These were the only ones I checked locally at the moment that use random tests. + #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 { }; @@ -184,7 +297,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) { @@ -192,8 +305,8 @@ 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)) - // These were the only ones I checked locally at the moment that use random tests. + #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) { @@ -244,7 +357,27 @@ void test() } } - #endif // (defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_DOUBLE_FLOAT) || defined(TEST_MPF_50)) + 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)); + } + } + + #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) @@ -282,6 +415,8 @@ int main() #ifdef TEST_MPF_50 test(); test(); + test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_MPFR_50 test(); @@ -294,6 +429,8 @@ int main() #ifdef TEST_CPP_DEC_FLOAT test(); test(); + test_issue722(); + test_small_a_in_default_ops(); #ifndef SLOW_COMPLER // Some "peculiar" digit counts which stress our code: test > >(); @@ -311,10 +448,14 @@ int main() #endif #ifdef TEST_FLOAT128 test(); + test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_CPP_BIN_FLOAT test(); test, long long> > >(); + test_issue722(); + test_small_a_in_default_ops(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT test(); @@ -322,6 +463,12 @@ int main() #if defined(BOOST_MP_CPP_DOUBLE_FP_HAS_FLOAT128) 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(); } diff --git a/test/test_round.cpp b/test/test_round.cpp index 56ee5a255..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) @@ -98,15 +101,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 +118,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 +158,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 +206,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 } } @@ -510,12 +513,17 @@ 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_sf_import_c99.cpp b/test/test_sf_import_c99.cpp index 457c87c45..160b00b9b 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 constexpr bool type_sets_errno(const T&) { return true; } #ifdef TEST_MPFR_50 template -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 -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 -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 -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 -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 -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 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 constexpr 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) @@ -696,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; } @@ -792,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) { @@ -832,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)) { @@ -854,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)) { @@ -864,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)) { @@ -876,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); @@ -895,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); @@ -1905,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; @@ -2263,6 +2273,7 @@ int main() #endif #endif #ifdef TEST_CPP_BIN_FLOAT + test_c99_appendix_F(); test(); test, boost::multiprecision::et_on> >(); #endif @@ -2295,10 +2306,17 @@ int main() test_c99_appendix_F > > >(); #endif #ifdef TEST_CPP_DOUBLE_FLOAT + test(); 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 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 { 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() diff --git a/test/test_various_edges.cpp b/test/test_various_edges.cpp index 9db4378cb..c3b5de4ff 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 { @@ -1324,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 @@ -1392,20 +1489,35 @@ 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); } } @@ -1479,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 @@ -1523,10 +1640,74 @@ namespace local return result_is_ok; } + + auto test_sqrt_integral_and_constexpr() -> void + { + #ifndef BOOST_MP_NO_CONSTEXPR_DETECTION + { + // 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))); + } + #endif // !BOOST_MP_NO_CONSTEXPR_DETECTION + } } // 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 +1716,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 +1731,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 +1746,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 +1764,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 +1780,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 +1796,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 +1813,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..d5f24715b 100644 --- a/test/test_various_edges_more.cpp +++ b/test/test_various_edges_more.cpp @@ -5,8 +5,13 @@ // Some parts of this test file have been taken from the Boost.Decimal project. -#include +#if !defined(TEST_CPP_DOUBLE_FLOAT) +#define TEST_CPP_DOUBLE_FLOAT +#endif + #include +#include +#include #include // Note: include this AFTER the test-backends are defined @@ -17,10 +22,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 @@ -32,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 + 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(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 + { + 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; @@ -152,6 +223,8 @@ namespace local } #ifdef BOOST_HAS_INT128 + // TBD: Is this supposed to work for cpp_double_double? + BOOST_IF_CONSTEXPR(!::has_poor_exp_range_or_precision_support::value) { for(auto index = static_cast(UINT8_C(0)); index < static_cast(UINT8_C(64)); ++index) { @@ -194,12 +267,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::lowest())) ) ); @@ -291,6 +367,138 @@ 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) + { + 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 +508,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 +531,37 @@ 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); + + 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); @@ -346,14 +577,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); @@ -383,25 +614,62 @@ 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); - float_type flt_zero_numerator { ::my_zero() * dis(gen) }; - float_type flt_finite_numerator { ::my_one() * dis(gen) }; + 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) + { + static_cast(index); + + 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); @@ -410,31 +678,399 @@ 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; } + 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 + { + 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) + { + 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 + { + 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; + } + + template + auto test_cpp_dec_float_rd_ovf_unf() -> void + { + using local_cpp_dec_float_type = CppDecFloatType; + + { + 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))); + } + } + + template + auto test_frexp_edge() -> void + { + using float_type = AnyFloatType; + + 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)); + } + } + } + + 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 { { - using float_backend_type = boost::multiprecision::cpp_bin_float<50>; + using dec_float_backend_type = boost::multiprecision::cpp_dec_float<50>; + using dec_float_type = boost::multiprecision::number; + + std::cout << "Testing type: " << typeid(dec_float_type).name() << std::endl; - using float_type = boost::multiprecision::number; + 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_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(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()); + // 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(); } { - using float_backend_type = boost::multiprecision::cpp_dec_float<50>; + using double_float_type = boost::multiprecision::cpp_double_double; - using float_type = boost::multiprecision::number; + std::cout << "Testing type: " << typeid(double_float_type).name() << std::endl; - std::cout << "Testing type: " << typeid(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_frexp_edge(); + local::test_double_fp_string_gt_max(); + } + + { + using big_bin_float_backend_type = boost::multiprecision::cpp_bin_float<512>; + using big_dec_float_backend_type = boost::multiprecision::cpp_dec_float<512>; - static_cast(local::test_edges()); + 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 +1081,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; } -#if defined(__clang__) -# pragma clang diagnostic pop -#elif defined(__GNUC__) +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