- Boost - lists.boost.org

[boost][decimal] Mungo's review
by mungo.gill＠me.com 13 Oct '25

13 Oct '25

Boost Decimal Review - Mungo Gill Firstly thank you to Matt for all the effort put into this sizable and clearly well thought out library. Here is my review of the Decimal library. - Background to this review I have used various floating point libraries in the past, mostly in financial applications, and am reasonably familiar with IEEE 754 for binary floating point, although I am less familiar with decimal floating point. I spent about a day writing small test programs, attempting to use it in my own code and stepping through function calls with the debugger. - Building and using I found the library relatively easy to download and use, the only exceptions being Windows ARM and assumptions made regarding fmtlib and format library availability (below). - - Compilation failures on Windows ARM When I tried to compile this on a Windows ARM (64-bit) box (using cmake and MSVC 2022), it failed due to the following error: …boost\decimal\detail\u256.hpp(691): error C3861: '_addcarry_u64': identifier not found (note: arm and arm64 windows probably need to be treated as a special case in the macro checks found in config.hpp lines 88-12. Note that on MSVC ARM the macro __ARM_NEON__ is not defined but arm_neon.h is provided as a header) - - fmtlib library support I tried building a program dependent on decimal on Windows (x64 built with cmake, MSVC 2022, C++20) and encountered an interesting issue: If the fmtlib library happens to be installed on the system then decimal attempts to #include the fmtlib library headers, encountering the following static_assert in fmt/base.h: static_assert(!FMT_UNICODE || use_utf8, "Unicode support requires compiling with /utf-8"); This occurred even though I had made no attempt (by this stage of testing) to write any code dependent upon either fmtlib or std::format. The checks in decimal/fmt_format.hpp should perhaps be tightened so that windows programs compiled without /utf-8 and which do not themselves use the fmtlib library do not give a compilation error. - - format library support The checks for whether or not the <format> header is available checks compiler versions. However, it is feasible that people are using a different standard library from the one you are assuming based on the compiler version (for example clang compilation may or may not have the -stdlib=libc++ flag, or someone might be using a modern clang with an older GNU libstdc++ lacking <format>). It would perhaps be more reliable to check for the __cpp_lib_format feature test macro that C++20 provides. - Points already mentioned by others in the mailing list As these have already been mentioned on the mailing list, I kept these points into their own section. - - Implicit conversions It is slightly confusing having implicit integer construction, but explicit floating point construction. Consider making all construction explicit. Although this leads to slightly more verbose user code, there is less opportunity for unintentioned conversions. Also confusing is the existence of a constructor taking a bool - for example the following code counter-intuitively prints 1 rather than the expected 3. I cannot personally imagine a good use case for wanting to implicitly convert a bool to a decimal. struct MyFloatType { double v_ = 3.14; operator int() const { return static_cast<int>(v_); } }; int main(int argc, char** argv) { MyFloatType f; boost::decimal::decimal64_t g(f); std::cout << g << std::endl; return 0; } - - Rounding I’m also not sure about the rounding convention being a global setting, and I’m not convinced thread-local overrides solve the problem. Perhaps some key functions could take an optional argument to override the global rounding setting ? - Other thoughts on the interface/design I thought this was a nice clean design, which covered most of what I would want covered by a decimal library. - - format library support The std::format support is somewhat lacking in flexibility, for example things like padding character specification (see https://en.cppreference.com/w/cpp/utility/format/spec.html) is not supported. (although I do appreciate that most standard library implementations don’t currently do the unicode width calculations correctly anyway, and supporting them would perhaps be excessive). Note: I did not do the same tests with the fmtlib library. - - locale support The level of locale support is undocumented. I would have included this in my documentation feedback but when I did a test I found that the implementation is also incomplete - i.e. it only appears to impact the decimal point specifier. Here is a simple reproducer (both output lines should be the same): std::locale a("en_US.utf8"); std::cout.imbue(a); std::cout << 1122.89 << std::endl; constexpr boost::decimal::decimal_fast64_t val4{ 112289, -2 }; std::cout << val4 << std::endl; - - cohort-aware functions Although I think the standard arithmetic operations and i/o should behave as they currently designed, there should be facilities to better exploit the fact that decimals can have different cohorts (for example facilities to add/subtract/multiply/divide where the resulting cohort is predictable and deterministic, albeit the preconditions would need to be quite tight to meet such requirements). A use of this would be to output a member of a cohort in a unique manner such that, when parsed, results in a decimal of the same cohort. - Other thoughts on the implementation Generally a good implementation, with clean, easy-to-follow code. I was able to step into operations using the debugger and did not find myself completely confused (although more code comments would always help :-) ) - - internal naming (this is an unduly picky point I know) The 32-bit, 64-bit and 128-bit implementations are called mul_impl, d64_mul_impl and d128_mul_impl. Perhaps for consistency the 32-bit should be d32_mul_impl. More notably, all 3 have comments talking about 128-bit arithmetic which looks to have been copied and pasted but which is not applicable to all 3. Similar points hold true for the division implementations. - - testing Although I understand the argument put forward in the mailing list that testing of special functions exercises the numerical precision, “interface testing” is quite light. For example a test that attempted to use a std::set<decimal32_t> would have quickly found the hashing issue mentioned in the mailing list. - Other thoughts on documentation Again, generally good, easy to read and understand documentation. Coming to this library for the first time I was quickly able to get up to speed. However, I did find myself having to look at the source code or the comments therein to find out how particular methods worked. - - Type conversions I may have missed it in the documentation, but the conversion rules between decimal types should be more clearly specified if they are not already (eg a decimal64_t can be converted to decimal128_fast_t but not to decimal32_fast_t). Also the documentation should specify the type promotion rules. For example, I failed to find in the documentation in the following code? constexpr boost::decimal::decimal_fast64_t val1{ 314, -2 }; constexpr boost::decimal::decimal64_t val2{ 2, 0 }; auto val3 = val1 * val2; - Conclusion My view would be that we should accept this library. Overall the documentation could be improved, and some useful features are missing, but in its current form (assuming the bugs and build issues mentioned above and in the mailing list are addressed) it is in a usable state and would be a useful addition to Boost.

2 4

[boost][decimal] Andrzej's review
by Andrzej Krzemienski 13 Oct '25

13 Oct '25

Hi Everyone, This is a review of the Boost.Decimal library. My knowledge about decimal floats is very superficial. In my job I need to deal with prices in all the World's currencies (string<->numeric conversion and simple additions and scaling) and for that I use a home-brew fixed-point implementation. I participated in the previous review, spent a couple of days studying the documentation, having a superficial look at tests and small pieces of implementation, running simple examples and filing bug reports. I would like to thank Matt and Chris for the huge effort to write and maintain this library, and for undergoing the painstaking process of Boost Review. The community needs this library, and I am happy that it is proposed for Boost. The nature of this library is very unusual: it implements types that belong in processors. We know it is needed for applications where accuracy and correctness is absolutely critical. Against other Boost libraries, it requires extreme measures for verifying correctness across the whole spectrum of values and cases. In a similar vein, in my opinion, it requires extremely detailed and comprehensive documentation. The bar should be higher than for an average Boost library. In this context, I have some concerns. While playing with the library I found three corner cases where it produces incorrect results: * https://github.com/cppalliance/decimal/issues/1091 * https://github.com/cppalliance/decimal/issues/1094 * https://github.com/cppalliance/decimal/issues/1119 Two are already fixed, and Matt has been very responsive, but I feel like it is too easy for a novice to find bugs in the library after a couple of minute's tests. It looks to me like the unit test "sieve" is still too coarse. Some test files (like test_decimal32.cpp or test_decimal64_basis.cpp) are commented out. Fuzz tests for decimal comparisons in random_decimal32_comp.cpp seem to be only testing decimals created from integer values (no fractions). I know that other Boost candidate libraries pass with fewer tests, but I feel this one needs to have a lot of them. I am not even sure how one tests user-defined literals across the spectrum. Maybe the unit tests should be written outside of C++. One can see that a lot of work went into preparing the documentation. It is helpful and already provides a lot of useful information, also about the background, and ideas. It has the "Design Rationale" section which reminds me of the high quality documentation that the original Boost libraries used to have. But I still find it insufficient. The API reference for the key types, like `decimal32_t`, only lists the class members, but there is no detailed description for the behavior of these members. What are the preconditions of the Decimal's constructors? Is any combination of values considered invalid? Or is it nicely degrading to subnormals and infinities? I think the contract of the library (how the cohorts are treated in comparisons, if they are implementation detail, or are observable?) need to be spelled out more clearly. Again, Matt has been very responsive, and the documentation has improved a lot during the review period, and I know it will improve further. Regarding the design, it looks like it has been done by IEEE, so not much to review here. I only had a short glimpse at the implementation, so I cannot say much. One thing that I found surprising is that operator<=> is implemented in terms of operators <, > and ==. Operator <=> was designed for the class authors to go the opposite way: define operator <=> and you get all the others for free. So I wonder what was the reason for the current implementation. I do not feel comfortable giving an accept or reject recommendation. I clearly have a higher acceptance bar for this library than for any other I have seen reviewed in Boost, and this may appear unfair. Do I want to see this library in Boost? -- yes. It is useful, and IEEE seems to agree. Are the authors the right people to implement it? -- definitely! But I would feel more comfortable accepting it, if it went through another review iteration. Could this be considered a conditional acceptance? In the case of the test sieve issue I brought up, I do not think it is a question of writing more tests. It is more a question of designing an approach to testing that would give a guarantee of correctness. This is requesting a lot of work from the authors who already put a lot of effort to get the library where it is. It is huge (both the library and the effort)! Again, this cannot be overstated. Matt and Chris: you did great work! Thank you! I know that sooner or later we will be able to use Boost.Decimal from the official distribution. Also, thanks to John Maddock for managing the review. Regards, &rzej;

3 3

Master regression tests failing
by Tom Kent 12 Oct '25

12 Oct '25

There seems to be a problem on master with all tests failing. It results in this in the log: error: Unable to find file or target named error: '/var/boost/run/boost_root/libs/system/build//boost_system' error: referred to from project at error: '../libs/graph_parallel/test' error: could not resolve project reference '/var/boost/run/boost_root/libs/system/build' Tom

4 4

[charconv] Possible bug
by Gennaro Prota 10 Oct '25

10 Oct '25

Hi, the following program prints "1e-01". Furthermore, it prints "Error: 132" if I change `size` to 20. It prints the expected "0.1" if I change the two using declarations to use the standard facilities. Tested against the master branch, with MSVC 2022. Is this a bug in CharConv? #include "boost/charconv.hpp" #include <charconv> #include <iostream> int main() { // using std::to_chars; // using std::chars_format::general; using boost::charconv::to_chars; using boost::charconv::chars_format::general; int const size = 100; char buffer[ size ]; auto const r = to_chars( buffer, buffer + size, 0.1, general ); if ( r.ec != std::errc() ) { std::cerr << "Error: " << static_cast< int >( r.ec ) << std::endl; return 1; } *r.ptr = '\0'; std::cout << buffer << std::endl; } -- Gennaro Prota <https://prota.dev>

2 1

[container] New deque implementation and future plans
by Ion Gaztañaga 10 Oct '25

10 Oct '25

Hi, I've been working lately on a new deque implementation for Boost.Container. The original uses the classic SGI STL-based data structure, that is quite bulky. The new implementation is already on develop and ready to be merged to master for Boost 1.90 The new implementation will try to be faster than std implementations (I probably need to work more on that with benchmarks), but more importantly, can allow some additional features. Some changes: - sizeof(deque) was 10 words, now is 4 words. Probably the lightest implementation around. - sizeof(deque::iterator) was 4 words, now is is 2 words (similar to libc++ and MSVC).) - Several internal algorithms were reimplemented to take advantage of the segmented nature of deque. - Defaults were slightly changed, 64 bit platforms now use 1024 byte blocks by default instead of the SGI classic 512 byte blocks (still far from libc++'s 4K blocks). - The new implementation eases further deque-like variations and optimizations in the future. Some planned features - Add a "stored_size_type" option so that the sizeof deque can be further decreased (probably down to 3 words) for those in 64 bit platforms that don't need more than 4G elements in deque. - Add a single-ended variation ("seque" might be confusing name because the data structure would not longer be a queue, but a segment-based sequence with random-access). Some people use deque to have a random-access container that avoids vector-like reallocations and guarantees stable pointers and references when inserting on the back. A double-ended container is sometimes sub-optimal for those use cases. - Add options (or maybe different containers or aliases reusing parts of the implementation) that can offer "reserve/capacity"-like features, so that a programmer can pre-allocate all the blocks that's going to use avoiding allocation performance penalties on hot code. I'll update the "Draft Development Plan for Boost.Container" (https://docs.google.com/document/d/1VdMTheFUczC946dP3VKPseOoUq3sVKjU73oMvK8…) with these proposals. Of course, I'm open to new proposals/features. If any booster is eager to test the new deque implementation or wants to suggest a benchmark/use-case that could be useful for Boost.Container users, please let me know! If anyone detects a bug in the new implementation please notify it and I'll try to solve it ASAP. Best, Ion

6 10

[static_string] Removing support for BOOST_STATIC_STRING_STANDALONE?
by Gennaro Prota 09 Oct '25

09 Oct '25

Hi, while discussing a PR on GitHub (<https://github.com/boostorg/static_string/pull/67>), we ran into the question of whether BOOST_STATIC_STRING_STANDALONE should still be supported. What's your take on it? Personally, I lean toward minimizing conditional compilation wherever possible. Also, the macro is used to avoid dependencies which are easily avoided anyway, so why not avoiding them unconditionally and have "standalone mode" as the only option? -- Gennaro Prota <https://prota.dev>

5 6

A string_view with null-terminator guarantee?
by Andrzej Krzemienski 07 Oct '25

07 Oct '25

Hi Everyone, Would Boost libraries benefit from having a string_view-like type with the guarantee that the underlying character sequence is null-terminated? This could be as yet another Boost library, or as part of Boost.Core. Maybe Boost already has such a type somewhere? The need for such a type surfaces time and again. When a library needs to be passed both const char * and std::string cheaply, only to pass it down to low-level C-libraries later. We have seen one recently during the review of Boost.Sqlite. One is again proposed for standardization: wg21.link/p3655. Regards, &rzej;

16 40

Minimum CMake version raised to 3.8
by Alexander Grund 02 Oct '25

02 Oct '25

Hi maintainers, the Boost superproject build now requires CMake 3.8 or higher. The reason for this is that the CMake feature `cxx_std_11` to declare the C++11 requirement was introduced in that version and is now used by a large amount of libraries, directly or indirectly. This change [1] was made due to users being confused about which CMake versions are required/supported (e.g. [2]). A couple libraries failed to declare the CMake 3.8 requirement even though they were using `cxx_std_11` leading to error messages that were not easy to understand to someone not used to CMake. I opened PRs fixing the requirements in a couple of repositories which I discovered during testing with a range of different CMake versions. Raising the minimum version to 3.8 reduces the number of versions to be tested with a low enough cost given the actual requirement by the many individual libraries and availability of that version (3.8 is old enough that it should be easily available to users, current versions are 3.31 and 4.1.) Note that some features of the Superproject require even higher versions: - BoostTestJamfile requires 3.9 - Automatic installation requires 3.13 So users should be using at least CMake 3.13 anyway. Stay safe! Alex [1] https://github.com/boostorg/boost/pull/1088 [2] https://github.com/boostorg/boost/pull/1081

1 0

[bloom] added bulk operations
by Joaquin M López Muñoz 01 Oct '25

01 Oct '25

For those interested in Boost.Bloom, I've just added bulk operations, which will make it into Boost 1.90: https://43.bloom.prtest3.cppalliance.org/libs/bloom/doc/html/index.html#tut… <https://43.bloom.prtest3.cppalliance.org/libs/bloom/doc/html/index.html#tut…> Joaquín M López Muñoz

2 2

Decimal Library re-review starting next week
by John Maddock 30 Sep '25

30 Sep '25

Just a quick reminder that the re-review of the decimal number library by Matt Borland and Chris Kormanyos starts next Monday the 6th of Oct. I know that Matt and Chris have been working hard to address the issues brought up during the first review, I filed these as bug reports and the original list and their resolutions can be seen here: https://github.com/cppalliance/decimal/issues?q=is%3Aissue%20state%3Aclosed… Looking forward to your feedback, John.

2 1