- Boost - lists.boost.org

End of Boost.Decimal Review
by John Maddock 25 Jan '25

25 Jan '25

The review of the proposed Decimal library has now ended - although given that there was a lot of lively discussion for me to sort through, there is still time to submit a late review if you wish. If I've counted correctly there were 5 reviews (4 on the list, one private): one firm reject and 4 conditional accept, plus many more people involved in the discussion than gave reviews. I have to be honest, I would have liked to have seen a couple more reviews in order to have reached a clearer consensus, so please bare with me while I sift through all the comments and try and reach a conclusion. My thanks to everyone who took part, and of course to Matt and Chris for submitting the library. Best, John.

1 0

GSoC 2025 Projects
by Matt Borland 24 Jan '25

24 Jan '25

All, In the modules thread and on Slack, I asked if Boost had a current plan for participation in GSoC 2025. I haven't received any responses yet, so I'll assume there isn't a plan. I'm wondering if anyone has: a) Projects they would like to propose for GSoC, and b) An interest in mentoring. Here are some ideas that I think could be beneficial and approachable: 1) A proof of concept for a Boost module, including distribution and installation processes, and potentially adding support to select libraries. This project could have easy access to the Clang and MSVC teams via their mentor it seems. 2) Bi-variate interpolation has been requested before in Math. ACM TOMS algorithms 751 and 761 could fit the bill, but their references are written in F77. A faithful translation and implementation of those papers would be a good start. 3) Chris Kormanyos and I are working on a cryptographic module that we intend to have certified under FIPS 140-3 and then propose to Boost. An extension of this could be a TLS project where a student provides a proof of concept with a generic file transfer server or similar that works securely with OpenSSL, and then also with our new module. I can mentor at least one of these projects. If anyone has past applications for the organization, please send a link or copies. We have until mid-Feb to apply as an organization, which I can do if no one else volunteers. Best, Matt

5 8

Another Boost.Decimal Review
by Jeff Garland 23 Jan '25

23 Jan '25

Thanks to Matt Borland and Chris Kormanyos for this good work. I vote to ACCEPT the library. I trust the authors to improve documentation, api, and performance as a matter of continued development. Let me say a few things about some discussions in the review threads up-front. *Standardization:* I'm an advocate for it and would be willing to help the authors with the process. Rationale: 1) this standardizes existing practice (aka IEEE 754), something like it is supported in many languages (specifically C23), and there's significant use cases for this in many domains even if it's slightly slower. 2) While a standalone library can go far, often a compiler/library can more easily optimize fundamental things like numeric types. 3) I spoke with Dietmar about the review and standardization -- he's still an advocate for having this capability, but has higher priorities at the moment. *N2849*: It's a decent design for 2009 -- less so in 2025. Specifically, w.r.t. conversion we should only perform automatic conversions from types (see below). The library already takes care of from_chars, format and some other more modern things N2849 wouldn't address. *C23 and _Decimal** Should this library consider being a layer over C23 types where that's possible? GCC supports them at least in a limited fashion. https://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html > Does this library bring real benefit to C++ developers for real world use-case? > Do you have an application for this library? Yes and yes. > Does the API match with current best practices? I have some quibbles here. *Construction*: template <typename T, typename T2>constexpr decimal32(T coeff, T2 exp, bool sign = false) noexcept; Is the sign flag helpful here? It seems simpler to just handle a negative coefficient -- like it already does. When I look at it there's already cognitive dissidence in my brain about if the sign flag *overrides* or *inverts* the coefficient sign. The N2849 api doesn't have this flag. *Fast Types:* I read through the list conversation about the _fast types. My suggestion is to drop them. Simplifies everything for users and implementers. The movement in c++ over the last decade(s) has been to precisely say the size of the type to ensure correctness and not 'let the platform decide' (aka uint32_t, int64_t, etc). In my comment on documentation you'll notice the c++20 extended floating point types *only provide* fixed sizes. Also N2849 and C23 don't support _fast types for decimal. *Conversions:* I'd like to see the library *pull back* on convertibility. long double ld{1.23456789234567}; decimal32 d(ld); // what happens -- round, truncate, doesn't compile? The best answer is doesn't compile. There's been significant work in the standard now to define floating point rank and limit conversions with the extended floating point types. Specifically: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1467r9.html#rank There's also other work on type traits and value preserving conversions in the SIMD capabilities. Also, std::chrono basically already does this -- any value destroying conversion has to be explicit. At a minimum the answer needs to be better documented - aka does what 754-2008 says? For other examples of things I'd remove and make a free function cast/round -- aka explicit user decision: class decimal64 { ... explicit constexpr operator std::int8_t() const noexcept; This is highly likely to not be value preserving so shouldn't be possible without a decision on how to handle overflow. class decimal64 { ... explicit constexpr operator decimal32() const noexcept; *Literals* constexpr auto operator "" _DF(const char* str) -> decimal32constexpr auto operator "" _df(const char* str) -> decimal32 Why not _d32, _d64, _d128? _df makes me think fast, not 32. > Is the documentation helpful and clear? Not bad, but as usual improvements can be made. As a user I'm going to need to select one of these types -- I'd love to see a table like this one at cppreference for named floating point types: *Type name* Defined in header <stdfloat> <https://en.cppreference.com/w/cpp/header/stdfloat> Literal suffix Predefined macro C language type Type properties bits of storage bits of precision bits of exponent max exponent std::float16_t f16 or F16 __STDCPP_FLOAT16_T__ _Float16 16 11 5 15 std::float32_t f32 or F32 __STDCPP_FLOAT32_T__ _Float32 32 24 8 127 std::float64_t f64 or F64 __STDCPP_FLOAT64_T__ _Float64 64 53 11 1023 std::float128_t f128 or F128 __STDCPP_FLOAT128_T__ _Float128 128 113 15 16383 std::bfloat16_t bf16 or BF16 __STDCPP_BFLOAT16_T__ (N/A) 16 8 8 127 Not sure how it renders in email so source: https://en.cppreference.com/w/cpp/types/floating-point Not looking for exact replication, but something like this. In the *using the library* section I'd like to see some: - examples of using it it math - examples of the behavior of NAN/inf values - conversions from other types like float expanded Where is the design decisions section? Some of the things I'm asking about should be covered in the docs. > Did you try to use it? What problems or surprises did you encounter? I didn't have time to play with it unfortunately -- godbolt would be helpful. That's all for now. Jeff

4 5

Re: [boost] Decimal: Formal review begins
by Glen Fernandes 23 Jan '25

23 Jan '25

I mentioned this to Matt, but I would like to see benchmarks comparing boost::decimal64_fast to a Decimal64 backed by Intel's DFP library, which is what I know to be in actual use today: https://www.intel.com/content/www/us/en/developer/articles/tool/intel-decim… Not that the benchmarks comparing to GCC's Decimal64 (which is based on the libbid which ships with libgcc) aren't useful, I personally don't know anyone using that today. Benchmarks should ideally also include Intel's compiler, because at least one of the relevant parties who motivated me to suggest the Decimal64 library (to Vinnie as a potential project) do use the Intel C++ compiler (and their Fortran compiler) for areas where they perform better. (The non-fast versions don't matter to me. I don't know anyone who would want to use them). Glen

12 36

Decimal Library: Last call for reviews?
by John Maddock 22 Jan '25

22 Jan '25

Formally, today is the last day of the Decimal Library review, so far there has been a lot of discussion, but only three full reviews with outcomes. Are there any more reviews incoming? Thanks, John.

1 0

My review of Decimal
by Ivan Matek 21 Jan '25

21 Jan '25

Hi everybody, PDF size exceeds ML limit so here is google drive link https://drive.google.com/file/d/1kH9WkeTDxN7FFqM_g7hV_-e3kJPlTGBr/view

6 16

Reminder to submit Boost.Decimal reviews
by John Maddock 20 Jan '25

20 Jan '25

Just a gentle reminder that the Decimal library review is currently ongoing, there's been plenty of discussion, but only one full review so far.... so if you're thinking of submitting a review, now would be the time ;) Thanks all, John.

1 0

Fw: Boost accepted in Google Summer of Code 2021
by Christopher Kormanyos 17 Jan '25

17 Jan '25

----- Forwarded Message ----- From: "boost-users-owner(a)lists.boost.org" <boost-users-owner(a)lists.boost.org>To: "e_float(a)yahoo.com" <e_float(a)yahoo.com>Sent: Wednesday, March 10, 2021 at 07:51:24 PM GMT+1Subject: Re: [boost] Boost accepted in Google Summer of Code 2021 To post messages to the Boost Users mailing list, you will need to subscribe this e-mail address via the Boost mailing list web page at: http://lists.boost.org/mailman/listinfo.cgi/boost-users You will need to take this step even if you intend to post only through GMane or some other news gateway. In this case, you may wish to edit your subscription options to turn off mail delivery. >> We're in again! > Thank you, David! Hi Matt (@mborland) This was, as far as i recall, our last successful timegetting into and finishing some GSoC 2021 projects. We had that whole Corona thing going on and it wasa tough time for everyone. As far as applying as an org, maybe David hassome old material. - Chris_________________________________________Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost

2 2

Adding logical implication to boost
by Ivan Matek 09 Jan '25

09 Jan '25

Hi everyone, there has been a recent proposal to add logical implication to C++ as an operator. github tracking issue <https://github.com/cplusplus/papers/issues/1641> P2971R2 <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2971r2.pdf> For a video description you can see this talk <https://youtu.be/bgyY3x8y4PE?feature=shared&t=1470> by Walter(it is only few minutes, not entire talk). While I agree with concerns mentioned on the issue, i.e. using a *precious *token => on rarely used functionality I do think that implementing a simple function helper is reasonable. Poll in issue shows that this is also likely standardization future. POLL: We agree with adding a function object logical_implication (tentative name, akin logical_and, `logical_or’). SF F N A SA 9 12 3 0 0 As for if it is worthwhile to add this simple logic to boost instead of people just writing their own I will just say I would prefer to have something named in boost instead of people reinventing same thing many times in their projects. I have used it few times in my career, so quite rarely, but again that means I have used it much more often than 80+% of algorithms in <algorithm> header. As for location I presume best place would be Boost.Algorithm although you could say that Boost.Core can be a candidate because it is a basic operation and would benefit from shorter namespace. I would be still inclined against this since I have seen core/util/common become huge in many codebases I have worked in. I have tried to check if this already exists in Boost; all I found was an example in Boost.Hana.

6 7

Forthcoming Decimal Library review (15th Jan)
by John Maddock 08 Jan '25

08 Jan '25

Just a gentle reminder that the review of the decimal number library by Matt Borland and Chris Kormanyos will start NEXT WEDNESDAY 15th Jan. The library is an implementation of IEEE 754 Decimal Floating Point Numbers. Documentation: https://cppalliance.org/decimal/decimal.html Code: https://github.com/cppalliance/decimal/ Motivation: Current C++ floating point types store the significand (often incorrectly referred to as the mantissa) as binary digits. Famously this leads to representation errors: https://0.30000000000000004.com <https://0.30000000000000004.com>. Decimal floating point numbers avoid this issue by storing the significand in base-10 (decimal). The other major difference between binary and decimal floating point types is that the latter allows for multiple representations of the same number. For example 1e5 could also be stored as 0.1e6, 0.01e7, so on and so forth. These are referred to as cohorts which binary does not have as there is only one way to represent each number in binary floating point. Use Cases: The use case for Decimal Floating Point numbers is where rounding errors are significantly impactful such as finance. In applications where integer or fixed-point arithmetic are used to combat this issue Decimal Floating Point numbers can provide a significantly greater range of values. For example, while a fixed-point representation that allocates 8 decimal digits and 2 decimal places can represent the numbers 123456.78, 8765.43, 123.00, and so on, a floating-point representation with 8 decimal digits could also represent 1.2345678, 1234567.8, 0.000012345678, 12345678000000000, and so on. I believe Matt has some minor doc updates to push between now and next week, but other than that the library is good to review (but hold your fire until we start next week unless you're away etc). Best, John.

1 0