- Boost - lists.boost.org

[release] Boost 1.69.0 Release Candidate 1
by Marshall Clow 07 Dec '18

07 Dec '18

The release candidates for the 1.68.0 release are now available at: <https://dl.bintray.com/boostorg/release/1.69.0/source/> The SHA256 checksums are as follows: af05616f71006f97833e130aad886c96136457511ace4b5496d6566e69cbe0ca boost_1_69_0_rc1.7z 8f32d4617390d1c2d16f26a27ab60d97807b35440d45891fa340fc2648b04406 boost_1_69_0_rc1.tar.bz2 9a2c2819310839ea373f42d69e733c339b4e9a19deab6bfec448281554aa4dbb boost_1_69_0_rc1.tar.gz d074bcbcc0501c4917b965fc890e303ee70d8b01ff5712bae4a6c54f2b6b4e52 boost_1_69_0_rc1.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

1 1

Executable files in Boost git repostories
by Edward Diener 06 Dec '18

06 Dec '18

We have again run into the situation where files with a Linux executable permission have been committed to various Boost git repositories, with Jim King creating a PR and list of these files in Boost Admin. I have fixed these for the repositories for which I have write access, and created PRs for the other repositories. But this begs the question as to what Boost's stance should be about adding actual executable files to a Boost git repository ? As an example a Linux bash command file was added to a particular repository and I created a PR to remove the executable file permission from the file. But the maintainer of the repository feels this is wrong and the Linux bash file should retain the executable file permissions and that the file should be part of the repository. But of course I am more interested here about the general principal of the matter. Obviously operating system command/batch files are executable files, but should they be so in a repository. Finally should be not have some sort of git hook that somehow eliminates this recurring problem of files with executable permissions being periodically committed to a Boost git repository ? Most all of the files I "fixed" or created PRs for are clearly source files what can not be "executed" in any way. But this happening again is a real problem to have to clean up each time.

9 22

Reminder: Boost Master branch will close for release tomorrow (12/5)
by Marshall Clow 05 Dec '18

05 Dec '18

Calendar at https://www.boost.org/development -- Marshall

3 3

[histogram] should some_axis::size() return unsigned or int?
by Hans Dembinski 04 Dec '18

04 Dec '18

Dear community (especially the reviewers of boost.histogram), I am still working on finishing the library based on the excellent reviews I got in September. I cannot make up my mind about a specific detail of the library interface and would like to ask for your input. Every axis type is required to have a size() method, which returns the number of bins along that axis (without counting extra bins for under- and overflow). Should this method return `unsigned` or `int`? = The case for `unsigned` = The size of an axis is non-negative, so the return type should reflect this. All the STL containers return their size as an unsigned integer. Naturally, boost.histogram should be as consistent as possible with the STL, so you don't have think about exceptions from the general rule. Whether `size()` returns a signed or unsigned type matters even in times of `auto`, since compilers like to warn about comparisons between signed and unsigned integers. These warnings and the STL have slowly thought people to write indexed loops with unsigned integers, like so: ``` auto h = make_histogram(…); // 1D histogram for (unsigned i = 0; i < axis.size(); ++i) { auto x = h[i]; // do something with bin } ``` We don't want to break this painfully learned habit by letting `size()` return a signed integer, because it would generate a warning in this naive loop. = The case for `int` = The type of the bin index returned by an axis is `int`, because it can be negative. An axis is required to return -1 when the axis represents an ordered range and the value fall below the low edge of the first bin. So the index must be signed. The size of an axis is highest index + 1. It would be natural to use the same type for `size()` and for the returned index. Internally in the library, there are many less-than comparisons between the index and the size of the axis. If the type of the latter is unsigned, the size must be cast to `int` in all these comparisons to avoid compiler warnings, which is adding code clutter in the implementation. The library provides a range adaptor, called `indexed`, which allows one to iterate over the bins of a histogram with a special proxy, that can return the current bin index and the accumulated value for that bin. The following naive code to ignore under/overflow bins while iterating will generate a warning when `size()` returns `unsigned` ``` auto h = make_histogram(…); // 1D histogram // iterate over indexed bin range, ignore indices < 0 and indices > size (= underflow/overflow bins) for (auto x : indexed(h)) { if (x[0] < 0 || x[0] >= h.axis().size()) // without warning only when x[0] and h.axis().size() both return `int` continue; // do something with bin } ``` People are supposed to use the indexed range to iterate over the bins and not a combination of simple loops like in the first listing, because it scales nicely to multi-dimensional histograms. In multiple dimensions, it is also potentially more efficient. The `indexed` range adaptor automatically moves sequentially in memory, which this is not guaranteed if the index is created by looping manually over several indices, like so ``` for (unsigned i = 0; i < h.axis(0).size(); ++i) for (unsigned j = 0; j < h.axis(1).size(); ++j) { auto x = h.at(i, j); // this may jump around in memory, causing cache misses } ``` How the linear index is generated from the multi-dimensional index is an implementation detail (although the implementation should probably anticipate these naive loops…) So, if `indexed` is anyway the default recommended way of iterating over a histogram, then size() should return `int` to be compatible with the index type, which is also `int`, because it makes naive code work better. Sorry for the long email, I would really appreciate your input. Best regards, Hans

6 13

Re: [boost] [graph] Tree data structure
by Bjorn Reese 02 Dec '18

02 Dec '18

On 11/28/18 11:51 AM, Jeremy Murphy via Boost wrote: > long ago, back in 2002 and 2009, Kasper Peeters proposed adding his tree > data structure to Boost. There is also Rene's proposal, which sounds like a useful Boost library: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3700.html

2 1

Re: [boost] [histogram] should some_axis::size() return unsigned or int?
by Hans Dembinski 01 Dec '18

01 Dec '18

Dear Jim, > On 29. Nov 2018, at 13:31, Jim Pivarski <jpivarski(a)gmail.com> wrote: > > It seems to me that if other C++ containers use unsigned integers for size(), you should too, for minimal surprise. The issue you raise about the "which bin?" function returning -1 would be solved in a very-strongly typed language like Haskell as an optional<int>. I know that C++ has optional types now, but I don't know how widely they're used or if there's a significant performance penalty. If this wouldn't look too weird in a C++ program and wouldn't slow it down (or needlessly complicate the code), an optional type would describe your intent more fully than -1. there is boost::optional, which has the semantics of a pointer and can be used to represent a type that stores a value or not. ``` boost::optional o = some_fickle_function(); if (o) { // optional has a value? auto value = *o; // "dereference" to get the value } else { // handle case where value is missing } ``` This is not a good match here, because -1 here does not have the meaning of "value is missing", but it really is the logical index for the virtual bin that spans from -infinity to the lower edge of the first bin in the axis. Value arrow: -inf ——————— | ——————— | —————— | —————— |—————————> +inf bin -1 bin 0 bin 1 bin 2 bin 3 I think representing the underflow bin with -1 and the overflow bin with the value returned by size() is very intuitive and elegant. Best regards, Hans

5 10

C++ project suggestion for Google summer of code (summer, 2019 )
by Ahmed Hussein 30 Nov '18

30 Nov '18

Dear boost , My name is Ahmed Mohamed Ahmed. I ‘m an Egyptian second year electrical engineering student (this is my third year but in Egypt we count 0,1,2,3,4). This my first time ever getting involved in open source. Nevertheless, I am eager to contribute to the vast open source community . I would love to create a C++ library under your supervision and guiding in the next Google summer of code (summer,2019). The attached document is an overview of the library, it is not a proposal with a time line but it answers questions regarding: How is this library going to benefit the open source community? What facilities will be provided by that library? What kind of libraries can be built by fellow programmers using this library? How can this library be extended in the future, whether by me or others? Thank you for your time . Sincerely Advanced mathematics for engineering applications <https://docs.google.com/document/d/1hxKHm0vv5nvia-d_OcGd3SG07gCf2ZtMQvDn_LF…>

1 0

Current Guidance on Compiler Warnings?
by Brian Kuhl 29 Nov '18

29 Nov '18

I'd like to confirm the guidance on Warnings I find here https://svn.boost.org/trac10/wiki/Guidelines/WarningsGuidelines is still considered current? context ... At Wind River we are in the process of working with Boost 1.68 and VxWorks 7 (with Dinkum 7.00 with and Clang 6.0 for ARM and IA boards and GCC 8.1 for PowerPC ) with the hope of bundling Boost with our product. Many of our customers make certified systems ( Planes, Trains, Medical Equipment, Factory Automation, etc. ) and the trend in theses industries is to be pedantic about eliminating all compiler warnings. While we have not traditionally required zero warnings in open source code shipped with our product, there is pressure on us to move in that direction, and as result we will probably be contributing pull requests specifically to fix or suppress compiler warnings over the coming years. I'd like to establish clear guidelines for my team as to what is an appropriate "coding standard" for Boost in regards to compiler warnings. While it is simple to say, everything displayed by -Wall, in practice there are many edge cases, e.g. is an unused parameter acceptable in test code? So I'd like to get the maintainers guidance. Many thanks Brian Kuhl

23 103

[graph] Tree data structure
by Jeremy Murphy 28 Nov '18

28 Nov '18

Dear Boost community, long ago, back in 2002 and 2009, Kasper Peeters proposed adding his tree data structure to Boost. http://tree.phi-sci.com/ There was a lot of discussion but nothing eventuated (so far as I am aware). There are links to the historical discussions on his website. ...2018.... Recently, a Boost.Graph user suggested adding a tree class to it, and I was like, "No, no, a tree is just a graph that satisfies certain constraints: a tree class won't yield better performance." But I also happen to be re-reading for nth time, Element of Programming, which touches ever so briefly but intensely on binary trees, and I realized "Oh, hold on, there is a world of conceptual difference between an arbitrary tree, and a k-ary tree." That discussion is here: https://github.com/boostorg/graph/issues/123 It seems very awkward to even try to represent a k-ary tree in existing Boost.Graph data structures, let alone a mutable k-ary tree. So I made a proof-of-concept, a mutable k-ary tree data structure with specialized implementations of depth-first search and isomorphism. Unless I've made a terrible mistake (which is possible), the performance gains are huge, and the ease of use in an existing library is also huge. OK, so huge things aside, this is really early days, exploratory work. And I'm no Boost.Graph expert. I'm interested in what people think, particularly whether they think it is an idea worth pursuing. I do. But I basically need help from people smarter and more experienced. I have made a PR for the sake of discussion, not for actually merging: https://github.com/boostorg/graph/pull/139 Cheers. Jeremy

1 0

[threads] Launch deferred for async
by Stephan Menzel 28 Nov '18

28 Nov '18

Hello all, I am using boost::async() to create futures from tasks in order to wrap some behavior that may or may not be sync. This behavior is implemented behind an interface and can be small and fast operations or longer running and blocking things. All return a future as a result type, so I can hide the ugly truth. For the smaller stuff I'd like to use launch::deferred to avoid threading altogether and just execute the task when the user get()s the future. boost::future<bool> ret = boost::async(boost::launch::deferred, [this] () -> bool { // do some small cpu only impl return result; }); But when i get the result: const bool result = ret.get(); ...the application crashes. Debugging this I came to this in boost/thread/future.hpp:9373 } else if (underlying_cast<int>(policy) & int(launch::deferred)) { std::terminate(); //BOOST_THREAD_FUTURE<R> ret; //return ::boost::move(ret); // return boost::detail::make_future_deferred_shared_state<Rp>( // BF( // thread_detail::decay_copy(boost::forward<F>(f)) // ) // ); } else { To me this sounds like the application will always std::terminate() when launch::deferred is chosen. Why is that? When I use launch::any it seems to work but why is there a parameter that always yields unwanted results. What is the reason behind it? Can I get launch::deferred as it is described (not threading, just executing the task sync when get() is called) somehow? Platform is x64 Windows 10, MSVC14.1. Cheers, Stephan

2 4