January 2020 - Boost - lists.boost.org

CMake Announcement from Boost Steering Committee
by Jon Kalb 13 Aug '24

13 Aug '24

The libraries produced by the Boost community have had a greater impact on the way that the C++ community writes code than any other library implementation. The focus of the Boost community will always be on the libraries, but it is undeniable that we are dependent on and often limited by the infrastructure of our trade. Years ago, the move to Git was contentious; yet, it was required to improve development. In a similar vein our build system has become an impediment for many developers and users, existing and prospective. Therefore, we, the Steering Committee, announce to the Boost community our desire and intent to move Boost’s build system to CMake for users and developers alike. We are soliciting comments and proposals from the community to guide the process and the goals. Our desire is that the community can come to consensus by the end of the calendar year with a vision of supporting users and developers. We understand that the actual process of achieving the end goal will be long, time consuming, and not without its share of conflict. We also recognize that the Boost community is comprised of bright and passionate individuals that are eager to get involved and help get work done. The members of the Steering Committee have been encouraged by the discussions and activity surrounding CMake on the mailing lists over the years and know that many people have voiced visions. We hope that each of you rejoins the discussion to support this initiative and contributes to the common goal of improving Boost’s integration into the broader C++ ecosystem. For the Boost Steering Committee, Jon Kalb, Chair jonkalb(a)boost.org

49 200

Adding my sorting algorithm, ska_sort, to boost, attempt 2
by Malte Skarupke 24 Nov '21

24 Nov '21

Hi everyone, I started a discussion about this in October, but at the time the maintainer of the sort library was busy, then I was busy, so now it's January... I wrote a generalized version of radix sort a couple years ago and gave a talk about it here: https://www.youtube.com/watch?v=zqs87a_7zxw I would like to get a new version of that sorting algorithm into boost. It's faster than what I showed several years ago. It's also even more general and has a new interface that should be easier to extend. I uploaded the code here: https://github.com/skarupke/sort/tree/master The documentation is also already updated with new benchmark results. Let me know what's required to get this into boost. Would you like this in the form of a pull request? One of the big things that probably needs review is the interface, since radix sorting works differently than comparison based sorting. For most normal uses you just need to provide a sort key, but more complicated cases can get more complicated. I tried very hard to make everything easy, but I'd also be curious if others can come up with better ways of doing the interface. Thanks, Malte -- Malte Skarupke malteskarupke(a)fastmail.fm

8 10

Optional library
by anshu khare 28 May '20

28 May '20

Hi mentors I was going through the optional library of boost. I was facing some problem in understanding the code base. In lines from 94 to 97 in optional.hpp, the code is as follows: struct in_place_init_if_t { Struct init_tag{}; explicit in_place_init_if_t(init_tag) {} //not able to understand this line }; I understand that we are creating a structure in_place_init_if_t and inside that we are creating another structure init_tag and then we are calling the constructor of in_place_init_if_t. But I am not able to understand that what does it the constructor do when we pass init_tag as an argument to it. Is it same as we are creating a structure Car and then creating another structure wheels inside it and passing wheels as an argument to the constructor of car as follows: struct car { Struct wheels{}; explicit car(wheels) {} //not able to understand this line }; Could you please tell what is the significance of passing wheels as an argument in this counter example?

2 1

binomial distribution setter function
by Kemin Zhou 18 Mar '20

18 Mar '20

This is my first time posting in this mailing list. Not sure how to post to the developer only mailing list after reading the document for mailing list for a good half an hour. If I posted in he wrong mailing please let me know and kindly provide the developer mailing list. I am looking at the binomial.hpp file. I need to use the binomial object in a loop which requires to have high performance. I am thinking constructing the binomial object each time in the loop would be less efficient than if I construct a single object, the each time reset the p parameter and use the object. I am not sure why the setter method was not provided. 296 RealType success_fraction() const 297 { // Probability. 298 return m_p; 299 } 300 void set_success_fraction(RealType p) { 301 m_p=p; 302 } Line 296 is the getter method, I added the setter method at line 300. -- Kemin Zhou 858 366 8260

4 4

[Boost.GIL] GSoC 2020 Project 1 - Seeking Mentor
by Ayush Bansal 01 Feb '20

01 Feb '20

Hi, I am a final year undergraduate student from IIT Khraragpur. I was interested in the project “Image Processing Algorithms” to be developed during GSoC 2020. I was mainly interested in implementation of Morphological IP Algorithms, Normalising channels and De-noising filters. I have a good knowledge about most of these algorithms and have worked with a lot of them as a part of my BTech Term Project. In addition to the list of algorithms provided for morphology, I had some other filters which I think could be implemented easily such as - Boundary Extraction, Hole Filling, Thinning and Thickening algorithms. Similarly, for de-noising filters, I was wondering if filters such as Conservative Smoothing, Adaptive Filters etc. could be added to the list. For my competency test, I was interested in doing the implementation of convolution filter and use it to detect edges. However, I did not understand where should I be posting my submission for the same. I have done my previous internship at Google India, where I implemented my code in Google’s Production server in C++, thus I also have the experience of writing good industry level code. I wanted to know if someone would be willing to mentor me for this project. Thanking you in advance. Regards Ayush Bansal Fifth Year Undergraduate Student Department of Computer Science and Engineering IIT Kharagpur

2 10

[Boost.Real] Testing Boost.Real in Visual Studio
by Jai . 30 Jan '20

30 Jan '20

Hi, I would like to contribute to the upcoming Real library. I have cloned the library at BoostGSoC19/Real. I wanted to ask whether it is possible to directly test the library in Visual Studio, or do I have to use CMake to build the project first? Thanks, Jai

4 5

URL library?
by Vinnie Falco 30 Jan '20

30 Jan '20

Is there any interest in a URL library for Boost? This is something that has been requested for a while now, and I've finally gotten around to it. Key features: * Construct a read-only url::view from a string_view * Construct a modifiable url::value from a string_view - Mutate the parts (e.g. set_scheme) - Set encoded or decoded strings: url::value u; u.set_username("Fr ed"); u.set_encoded_password("pass%20word"); - Retrieve encoded or decoded strings: u.username(); // returns decoded std::string u.encoded_password(); // returns encoded string_view For servers, execution paths are provided to avoid all dynamic allocation. For example to retrieve the decoded username: url::static_pool<4000> sp; std::cout << u.username( sp.allocator() ); The std::basic_string returned by username() uses the specified allocator. A server can handle URLs without allocating any memory. There's some punycode conversion routines but I haven't figured out if they should be part of the library, or how they would manifest as APIs (for international domain names). You can perform calculations with URLs using an Allocator (default to std::allocator<char>), or you can use a container with "static storage" (e.g. fixed_string): url::static_value<4000> u; // 4000 char capacity The library is here: <https://github.com/vinniefalco/url> This is still a work in progress, and I'm open to feedback that might help me make better remaining design choices. Thanks

8 23

Re: [boost] Yet Another Container: DynamicArray
by Gavin Lambert 29 Jan '20

29 Jan '20

At 19:02 29/01/2020, Glen Fernandes wrote: >You shouldn't expect that. For any unique_ptr<T, D> you can only >expect that .get() gives you a D::pointer. For default_delete<T> >this might be T*. But it always depends on the Deleter. That seems like a significantly more annoying interface than std::shared_ptr uses. shared_ptr can hold fancy pointers too, but it happens explicitly via using fancy<T> rather than plain T, so the explicit indirection on usage is obvious too. Having that be an implementation detail of the deleter changing the effective "type" of the first template argument (which is what people think of as the type of the pointer, even if the standard disagrees) seems quite annoying. Maybe we should have a type-erased unique ownership pointer as well. I know the reason why we didn't was to avoid heap allocation or wasted storage for the common case, but there ought to be some happy middle ground. >The correct way to get a raw pointer from any >potentially-fancy-pointer x is: to_address(x) > >This can be boost::to_address (C++03 or higher), or >std::to_address (C++20 or higher) Hmm. This is news to me; I don't think I've read about it anywhere in conjunction with unique_ptr. Perhaps since it doesn't actually exist yet (most compilers are still mostly C++17). But eg. <https://en.cppreference.com/w/cpp/memory/unique_ptr>https://en.cppreference.com/w/cpp/memory/unique_ptr appears entirely mute on the topic. (There's a passing reference to fancy pointers but even that doesn't talk about it.)

3 2

Re: [boost] unique_ptr<T, D> and D::pointer and fancy pointers
by Glen Fernandes 29 Jan '20

29 Jan '20

Gavin, in case my explanation in that earlier reply wasn't clear: Given std::unique_ptr<Foo, D> p; 1. Users know that *p and p->x do the right thing by Foo. 2. p.get() will get them a D::pointer. This D::pointer might be Foo*, or it might be offset_ptr<Foo> or it might be alloc_ptr<offset_ptr<Foo>> or any other pointer-like type. To get a Foo* out of p.get() regardless of which of the above three it returns, you can call: Foo* q = std::to_address(p.get()); // C++20 in std, C++03 in boost Or, if you know that p is not a null pointer, you can also use: if (p) { Foo* q = std::addressof(*p); // C++11 in std, C++03 in boost } std::unique_ptr<T, D> was always designed for this (since C++11). Because not all pointers we use are raw pointers. An Allocator::pointer might not be X*, it might be offset_ptr<X>, or it might be aligned_ptr<offset_ptr<X>>. This property of unique_ptr is also unrelated to allocate_unique (which just leverages this with a fancy-pointer around the Allocator::pointer which in turn might be a fancy-pointer). But even today, users are using unique_ptr with non-raw pointers (like Allocators where Allocator::pointer is offset_ptr<X> instead of X*). They don't assume that p.get() returns a raw X* pointer. This might be a lesser known property of unique_ptr to some (especially those that do not work much with custom allocators), but this is the way it has always been and intentionally so. Glen

1 0

Yet Another Container: DynamicArray
by Christian Mazakas 29 Jan '20

29 Jan '20

I've been working on an AllocatorAwareContainer called `dynamic_array` and was wondering if there'd be any interest in including it in Boost. First and foremost, a link to the source code: https://github.com/LeonineKing1199/sleip `dynamic_array` is a heap-allocated array that can't be resized (without entirely re-assigning it). It's useful in cases where you'd normally use `std::vector` but have no need of `push_back`, `emplace_back`, or any of the other size modifiers that the container supports. These kinds of arrays are typically useful in I/O applications which normally only accept a pointer-size pair to write out to. Naturally the question arises, "why use `dynamic_array` in the year 2020 when we have `std::vector` and `boost::allocate_unique`?". `std::vector` imposes a constant storage cost of pointer, size, and capacity. `dynamic_array` only stores a pointer and a size making it slimmer in use-cases where there's no need of a separation between size and capacity. `dynamic_array` also supports constructors `std::vector` doesn't have. For example, `dynamic_array` is constructible from a Range and has a `noinit` constructor. `dynamic_array` even supports array objects which gives it another advantage. `boost::allocate_unique` is a significantly tougher class to beat because it boasts many of the same features: a dynamic allocation done using the supplied Allocator supporting `noinit` construction and array objects with a size (stored in the Deleter of the returned `std::unique_ptr`). And while it is true that `boost::allocate_unique` enables all of this, it still lacks a few key semantics. Namely, `dynamic_array` is copyable. It's also copy assignable and move assignable, including the case where the underlying allocators do not use the same memory resource and will instead perform a piece-wise move of the elements. It's arguable whether or not `std::unique_ptr` should support similar semantics so in the interim, `dynamic_array` is the next best thing. - Chris

8 25

[Boost.Config] Should BOOST_FORCEINLINE depend on NDEBUG?
by dariomt＠gmail.com 29 Jan '20

29 Jan '20

Right now BOOST_FORCEINLINE does not depend on NDEBUG. This means that on Debug builds the code asks to be forced-inlined with optimizations disabled, which does not make much sense to me. This is reflected by a myriad warnings in msvc under level 4 warnings. In fact Multiprecision library works around this issue by defining their own macro BOOST_MP_FORCEINLINE which decays to just inline in Debug builds (boost/multiprecision/detail/number_base.hpp lines 25-29). I think this behavior should be adopted by BOOST_FORCEINLINE. I'm happy to do a PR if there is agreement from maintainers.

3 2

Re: [boost] Yet Another Container: DynamicArray
by Glen Fernandes 29 Jan '20

29 Jan '20

I wrote: > Yes quite. i.e. What you believe is not true about boost::allocate_unique. > > i.e. For auto p = boost::allocate_unique<T[]>(a, n); > assert(p.get().size() == n); > > This is because the unique_ptr stores a pointer adaptor around the > Allocator::pointer which also stores the size. > > So the pointer and size are stored together in the unique_ptr result. Note, that the size is only stored for allocate_unique<T[]>(a,n) but not for allocate_unique<T[N]>(a) since there the N is known at compile time. For auto p = allocate_unique<T[N]>(a); your p.get().size() will return N, but there's no need to store a size_t for N, so we don't. > To get the plain Allocator::pointer out of it you can use p.get().ptr() > > Or, for example, p.release().ptr() for someone who wants to manage > it themselves. Glen

1 0

New allocator that uses global memory
by Frederick Gotham 26 Jan '20

26 Jan '20

I propose a new allocator that uses global (i.e. static duration) memory. Here is my current experimental code: #include <cstddef> /* size_t */ #include <new> /* Only for bad_alloc */ static int this_translation_unit; /* This serves the same purpose as __FILE__ */ template<typename T, std::size_t t_capacity, std::size_t t_counter, int *t_file = &this_translation_unit> class StaticAllocator { protected: static T buf[t_capacity]; public: typedef T value_type; template<typename U> struct rebind { typedef StaticAllocator<U, t_capacity, t_counter, t_file> other; }; T *allocate(std::size_t const n) { if (n > t_capacity) throw std::bad_alloc(); return buf; } void deallocate(T *, std::size_t) { /* Do Nothing */ } }; template<typename T, std::size_t t_capacity, std::size_t t_counter, int *t_file> T StaticAllocator<T, t_capacity, t_counter, t_file>::buf[t_capacity]; using std::size_t; #include <vector> using std::vector; #include <iostream> using std::cout; using std::endl; auto main(void) -> int { vector< char, StaticAllocator< char, 4, __COUNTER__ > > v; v.push_back('a'); v.push_back('b'); v.push_back('c'); v.push_back('d'); for (auto const &elem : v) cout << elem << endl; vector< char, StaticAllocator< char, 4, __COUNTER__ > > v2; v2.push_back('x'); v2.push_back('y'); v2.push_back('z'); for (auto const &elem : v2) cout << elem << endl; // Now try the first vector again for (auto const &elem : v) cout << elem << endl; } The trick I'm using with "this_translation_unit" compiles just fine on GNU and Clang, however it fails on Microsoft because the variable has internal linkage. I'm sure this can be done another way using Boost preprocessor stuff. The preprocessor macro "__COUNTER__" is available on every C++ compiler I know of. Frederick P.S. This is my second idea to the Boost development list. My first one is "istream_iterator_limited".

2 1

boost/asio/awaitable.hpp including <experimental/coroutine>
by Paps Olo 25 Jan '20

25 Jan '20

Hi, i've been trying to get the coroutine chat example to work, but it seems that in 1.72 and 1.71 boost/asio/awaitable.hpp does not compile when BOOST_ASIO_HAS_CO_AWAIT has been defined. Is there something i overlooked (i've been away from Linux development for some years...) or is boost really broken with this define? Which version should i try, or is there any sense in trying to fix this myself? Best regards papsolo

4 4

Re: [boost] dynamic_*<T>
by Glen Fernandes 24 Jan '20

24 Jan '20

Alexander wrote: > So if T[] and T[N] are valid, then T[N][M] should also be. This increases the scope greatly but has an incredible difficult questions to answer: What would operator[] return? I don't have a good answer... Simple questions that already have an answer: The same way shared_ptr<T[N][M]> works today. :) Its operator[] returns element_type& So: auto p = allocate_shared<int[5][1024]>(alloc); p[3][675] = 8; auto q = allocate_unique<double[][2][3][4]>(alloc, size); q[index][1][1][1] = 0.95; Then: dynamic<int[5][1024], Allocator> a(alloc); a[3][675] = 8; i.e. Making it work for T[N] also automatically makes it work for T[N][M]. Glen

2 1

[license] Boost license question
by Edward Diener 24 Jan '20

24 Jan '20

If some compiler vendor takes a version of Boost and makes changes to that version of Boost to suit the particular compiler, while distributing that version with full source code as an optional part of some release of that compiler, does this mean that the code is now proprietary for that compiler vendor ? Or does the code still remain open source so that a programmer can use the changes made to update his own version of a Boost release or provide PRs to some later release of Boost based on the code in the compiler vendor's release ?

4 6

[Boost][GSoC]New algorithm for multiplication
by Debajyoti Dasgupta 23 Jan '20

23 Jan '20

Sir/Ma'am, I am highly interested in working on the multiprecision big number types . I wanted to propose that since In the proposed project there is an increase in precision from 1000 to 10000 decimal digit , we can implement toom-cook algorithm instead of the standard karatsuba multiplication.Toom cook algorithm has a complexity of O(n^1.465) which is quite faster than karatsuba multiplication O(n^1.58). Please share your views on this. Thank you

2 2

Willing to take part in GSOC 2020 with Boost.
by Ram Nad 23 Jan '20

23 Jan '20

Dear Mentors, I am a second year undergraduate student from India. I would like to work with Boost.Multiprecision library. I have completed Programming competency test and would like to familiarise myself with the code base. It would be really helpful if you could guide me on where to start. Thanks You Ram Nad

2 1

Anyone got AT commands work using asio serial port?
by JH 22 Jan '20

22 Jan '20

Hi, There are many boost serial port sample code out there, but none of them I can run AT command. I have a device connected to my ubuntu 18, I can run AT command on minicom to get correct response, but I could not get any AT response from boost serial port. Has anyone made it work? Thank you. Kind regards, - jh

5 11

New Boost Review Wizard: Mateusz Loskot
by Glen Fernandes 20 Jan '20

20 Jan '20

Our thanks to Mateusz for agreeing to help Boost with the formal review process. https://www.boost.org/community/reviews.html has been updated to say: > The role of Boost Review Wizard is currently played by: > * Mateusz Loskot (mateusz at loskot dot net) > * John Phillips (johnphillipsithaca at gmail dot com) > > Past Review Wizards (we thank you for your service): > * Ronald Garcia Glen

2 1

Optional library
by anshu khare 19 Jan '20

19 Jan '20

Hi I ran the following code: const std::string i = "some string"; boost::optional<const std::string&> str = i; cout << get_optional_value_or(str, "some other string") ; It gives the output as : some string Which is absolutely fine. But when I run const std::string i = {}; boost::optional<const std::string&> str = i; cout << get_optional_value_or(str, "some other string") ; The output is an empty string. Shouldn't it give "some other string as output" because if I run the same code with integer it gives the second parameter of get_optional_value_or() as output?

2 5

New Boost Review Wizard: Volunteers
by Glen Fernandes 18 Jan '20

18 Jan '20

We need a new Review Wizard to take Ron's place. The duties include coordinating with review managers, scheduling reviews, and updating the website accordingly. Or as https://www.boost.org/community/reviews.html#Wizard puts it: > * When a formal review is requested for a library: > ** Approve the review manager based on their participation in the Boost community, including the mailing list, previous reviews, and other forums. > ** Suggest a schedule, after checking (via private email) availability of the review manager and library author. > ** Finalize the schedule, once the review manager verifies the library is actually ready for review. > ** Resolve schedule slips or other issues with review managers and submitters. > * Maintains a schedule of both past and pending reviews, in the form of the Review Schedule web page. > * Resolves questions from review managers and library submitters, who sometimes want a third opinion on questions such as "Should we extend the review period because ...?" > * Monitors the general review process, and makes minor adjustments as needed, or queries the list about possible major adjustments. When we appoint the new Review Wizard, I can grant them access to boostorg/website and provide more details about how to update it. We would like someone who is a Boost library author or contributor if possible. Any takers? Glen

3 3

GSoC 2020 and Boost C++
by David Bellot 18 Jan '20

18 Jan '20

Hi Boost community, Boost C++ will apply again this year to be a mentoring organization for the Google Summer of Code. We are seeking mentors with good projects to join us and have the chance to mentor students from all around the world and contribute code to one of the Boost library. Applications for organization open tomorrow and are open until February 5th. We will apply as usual. In the meantime, help me and propose new projects, declare yourself as a potential mentors on the Boost mailing list and start editing the page at https://github.com/boostorg/boost/wiki/Google-Summer-of-Code%3A-2020 with your own project. Best regards, David

1 0

Potential Mentor's Interest in Boost GSoC2020
by Christopher Kormanyos 18 Jan '20

18 Jan '20

Dear Boost, A generic reminder that org applications GSoC 2020has reached me in another forum yesterday. I'm not the organizer of this, but a potential mentor.Do other potential mentors have suitable projectsand interest in mentoring? Based on previous years,interest this year seems less strong. But the timeto get involved is upon us. I posted one of my potential projects here: https://github.com/boostorg/boost/wiki/Google-Summer-of-Code:-2020 ...And it has remained alone for almost 1 week. Best regards, Chris

4 4

Extension of math/complex library
by anshu khare 17 Jan '20

17 Jan '20

Hi mentors, I would like extend math/complex library in which the user will be able to compute roots of equation like z^n - a =0 where n,a € R+. Example : z^4 - 1 = 0 Anshu

1 0