July 2016 - Boost - lists.boost.org

Gmane going away
by Tom Kent 07 Sep '16

07 Sep '16

So it looks like Gmane is under attack and the guy who runs it is thinking about just turning it off (that would be sad). https://lars.ingebrigtsen.no/2016/07/28/the-end-of-gmane/ Anyway, I know a lot of boost users use is as the gnu mailman archive pages are really hard to use. I would like to propose that we (specifically the list owner(s)) mirror the boost mailing lists to the mail-archive.com site. It has good search features and decent thread browse-ability. Thoughts? Tom

8 9

Re: [boost] double_ended - request formal review
by Mathias Gaunard 23 Aug '16

23 Aug '16

On 15 July 2016 at 16:51, Benedek Thaler <thalerbenedek(a)gmail.com> wrote: > Dear Boost, > > I'd like to request the review of the double_ended library. > > Code: https://github.com/erenon/double_ended > Documentation: http://erenon.hu/double_ended > > The library contains two classes. Excerpt from the documentation: > > * `devector` is a hybrid of the standard vector and deque containers, as > well as the small_vector of Boost.Container. It offers cheap (amortized > constant time) insertion at both the front and back ends, while also > providing the regular features of std::vector, in particular the contiguous > underlying memory. In contrast to the standard vector, however, devector > offers greater control over its internals. Like small_vector, it can store > elements internally without dynamically allocating memory. Not related to your request per-se, but I think this occasion is as good as any to discuss the library. devector is an interesting variant of vector, but it gives the illusion that is could be used as a queue. However given the implementation, it seems elements removed from either end will never be reclaimed. I suggest documenting that limitation or having a threshold above which memory is actually freed.

4 5

[CallableTraits] Seeking Review Manager
by Barrett Adair 23 Aug '16

23 Aug '16

Boost Developers, CallableTraits is a C++11/14/17 library for the inspection, synthesis, and decomposition of callable types. CallableTraits aims to be the "complete type manipulation facility for function types" mentioned in the final paragraph of C++17 proposal p0172. Library: https://github.com/badair/callable_traits Docs: http://badair.github.io/callable_traits/doc/html/index.html Boost Library Incubator: http://blincubator.com/bi_library/callabletraits-2/?gform_post_id=1574 Current Version: 1.0.1 I've received some great feedback on the mailing list. I consider the current version to be production-ready, which includes excellent cross-platform test coverage and thorough documentation filled with examples. Does anyone wish to be a review manager for this library? It is not a very large codebase, although the implementation is config-heavy and relatively noisy. The Library Submissions page on the Boost website indicates that a library manager should be found before requesting a formal review, but I noticed that there are many "scheduled reviews" that do not have a library manager. May I request a review as well? Thank you, Barrett

3 3

[graph] Sync develop with master?
by Murray Cumming 12 Aug '16

12 Aug '16

Now that Boost 1.61 is out, it would be great if the various fixes in boost graph's develop branch could be merged/cherry-picked/whatever to master, please. There seem to be a couple of years of fixes that have not appeared in a release. -- Murray Cumming murrayc(a)murrayc.com www.murrayc.com

5 21

[boost-process] Beta & Review
by Klemens Morgenstern 07 Aug '16

07 Aug '16

Hi, boost-process is now in beta, you can check it out here: https://github.com/klemens-morgenstern/boost-process and read the doc here: http://klemens-morgenstern.github.io/process/ It will probably be in review in the beginning of November, Antony Polukhin will be the review manager. I really hope I'll get some feedback before that, so I can work on the weak points and also get more detailed in the documentation. Thanks, Klemens

4 10

Review Schedule and Review Manager for PODs Flat Reflection (ex magic_get)
by Antony Polukhin 05 Aug '16

05 Aug '16

Hello, PODs Flat Reflection (or PFR) is a C++14 library that represents POD structures as tuples and provides tuple-like methods for PODs. Library has a set of predefined operators for PODs and useful functions for everyday use. Works with user-defined types without any macro or boilerplate code. Library: https://github.com/apolukhin/magic_get Docs: http://apolukhin.github.io/magic_get/ Boost Library Incubator: http://blincubator.com/bi_library/pfr-pod-flat-reflection/?gform_post_id=16… Could the PODs Flat Reflection library be put on review schedule? Anyone wishing to become a Review Manager for the library? -- Best regards, Antony Polukhin

6 9

[config] RFC PR 82
by Domagoj Saric 01 Aug '16

01 Aug '16

Hi everyone, I am finally getting back to (trying to) contributing some of my personal projects to Boost. For two of those, Err (https://github.com/psiha/err) and especially Functonoid (a C++11 generalization and rewrite of my previous Boost.Function related work) I need some lower level codegen and/or optimiser control functionality (i.e. portable macros wrapping toolset specific attributes and pragmas) that I've added to my personal fork of Boost.Config and which I've now submitted in the subject PR (https://github.com/boostorg/config/pull/82) I don't expect this PR to be accepted as is/'just like that' so I'm opening this thread where we can discuss which of those changes/macros are welcome, which need more work and which, for some reason, should not be part of Boost.Config (and which, in turn then, I have to move to some 'internal implementation headers' in libraries that will need them). To avoid 'spamming' (and save time;) I'll skip the explanation of the individual macros as I expect them to mostly be self-explanatory (if not from their name then from the minimal Boost.Config documentation additions that are part of th PR). ps. I'll be on the (off) road for the next three weeks so I don't know when I'll be able to respond until I get back... -- "What Huxley teaches is that in the age of advanced technology, spiritual devastation is more likely to come from an enemy with a smiling face than from one whose countenance exudes suspicion and hate." Neil Postman

8 31

constexpr, cmath functions and other functions and distributions
by Paul A. Bristow 01 Aug '16

01 Aug '16

After much head scratching (and some head banging) - against a string of "Computer Says No" inscrutable diagnostic messages. I believe that I have now produced a (partial) version of Boost.Math normal_distribution that can be a constexpr using GCC6.1.1. (diagnosis has got to improve if constexprizing existing code is to become popular? ) constexpr normal_distribution<double> n01(0., 1.); producing this code 960 .loc 1 47 0 961 000d 660FEFC0 pxor %xmm0, %xmm0 # tmp89 962 0011 F20F1145 movsd %xmm0, -32(%rbp) # tmp89, n01.m_mean 962 E0 963 0016 F20F1005 movsd .LC1(%rip), %xmm0 #, tmp90 963 80080000 964 001e F20F1145 movsd %xmm0, -24(%rbp) # tmp90, n01.m_sd 964 E8 and more interestingly, a PDF can be calculated at compile-time constexpr double p = pdf(n01, 0.5); 965 .loc 1 56 0 966 0023 F20F1005 movsd .LC2(%rip), %xmm0 #, tmp91 966 88080000 967 002b F20F1145 movsd %xmm0, -8(%rbp) # tmp91, p 967 F8 Perhaps the assembler whizzes can confirm that this looks like a compile-time computation? This relies on lots of C++14 and 17 constexpr features, and Most crucially it relies on being able to use several cmath functions as constexpr. For a couple of trivially simple examples: abs(x) and isfinite(x). constexpr double ax42 = abs(-42.); // Unspecified version of abs. constexpr double ax42g = ::abs(-42.); // C double version? constexpr double ax42b = __builtin_abs(-42.); // builtin GCC only constexpr double ax42s = std::abs(-42.); // std:: version Without most cmath functions it seems to me impossible to write any reasonable (so-called special or not) mathy function or statistical distribution that can be constexpr. At present, only GCC 6.1.1 authors have foreseen this need and provided these so-called built_in_* cmath function versions that are constexpr, see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html. (Aside on other compilers: · Clang 3.8 has some problem deep inside type_traits that I haven't yet investigated. · VS2015 update 3 still doesn't compile many essential C++17 features from my experiments so far, and doesn't provide any constexpr cmath functions. ) The many potential benefits of compiler-time computations are quite enticing to contemplate :-) * No run-time where possible * Errors caught at compile-time * Improved code readability * Reduce executable footprint and potentially most important * Avoid global initialization order issues * Avoid initialization thread races See · Scott Schurr, C++ Developer, Ripple Labs https://cppnow2015.sched.org/event/2oLK/constexpr-c-at-compile-time · Dietmar Khul Constant Fun https://www.youtube.com/watch?list=PL9hrFapz4dsM1B9bI8VmEE4JJlR0m-dvo <https://www.youtube.com/watch?list=PL9hrFapz4dsM1B9bI8VmEE4JJlR0m-dvo&v=T37…> &v=T37ElKPICvo&app=desktop Is there any support for making std::abs and friends constexpr where possible in future versions of the C++ Standard? Paul PS I can't conceive of any UDT using or providing floating-point without some function like frexp to get and set exponent and significand. I also note that making constexpr frexp and ldexp and other functions passing a pointer to a variable to be updated may be more difficult/impossible, and is very likely to require at least initialization of the to-be-updated variable before calling frexp. I've investigated overcoming this by writing a naïve new constexpr version of frexp returning a std::pair (significand and exponent) but, of course, it can never be a 'drop-in' replacement because it has a different signature, so lots of code changes are inevitable. --- Paul A. Bristow Prizet Farmhouse Kendal UK LA8 8AB +44 (0) 1539 561830

5 6

[type_erasure] Do we have a maintainer (minor fix needed)?
by John Maddock 31 Jul '16

31 Jul '16

This trivial PR is open for type_erasure and fixes an issue introduced by changes to Boost.Config (enabling constexpr support for VC14up3). https://github.com/boostorg/type_erasure/pull/11 BTW the failure is not caused by buggy constexpr support, there's some other issue going on once that code path is enabled. Anyhow, since we really should be merging Config to master soon, I'd like to see this collateral-damage fixed if possible. Thanks, John.

1 0

[contract] Template types
by Lorenzo Caminiti 29 Jul '16

29 Jul '16

Hello all, I would like to discuss the extra type requirements that contracts can impose of generic types and how Boost.Contract handles that. I think I mentioned some of this already in different emails to this list, but I wanted to summarize this topic in one email. For example, note that the following code will not compile when the old value template parameter T is not copyable: template<typename T> void swap(T& a, T& b) [[ensures: a == old(b)]] ... In Boost.Contract (approach 1): template<typename T> void swap(T& a, T& b) { boost::contract::old_ptr<T> old_b = BOOST_CONTRACT_OLDOF(b); boost::contract::guard c = boost::contract::function() .postcondition([&] { BOOST_CONTRACT_ASSERT(a == *old_b); }) ; ... } In some cases, that might be what the contract writers want: the generic old value type T is not copyable so postconditions cannot be checked and the program should not compile. However, in some other cases the contract writes might not want to add the extra copyable requirement on T and check the related postconditions only when callers specify a template parameter T that happens to be copyable. That can be done allowing some sort of static-if in contracts: template<typename T> void swap(T& a, T& b) [[ensures: static if(is_copyable<T>::value) a == old(b)]] ... In Boost.Contract (approach 2): template<typename T> void swap(T& a, T& b) { boost::contract::old_ptr_if_copyable<T> old_b = BOOST_CONTRACT_OLDOF(b); boost::contract::guard c = boost::contract::function() .postcondition([&] { if(old_b) BOOST_CONTRACT_ASSERT(a == *old_b); }) ; ... } Both approach 1 and 2 above are valid and should be supported by the framework. The decision between which approach to use for a specific contract should be left up to the programmers. Like old values can introduce the extra copyable type requirement, any contract assertion can in general introduce an number of extra requirements on generic types, namely the type requirements necessary to support the operations used to program the contract assertions. For example, the following code will not compile if T is not equality comparable (which is not a type requirement vector normally imposes on T): template<typename T> class vector { void push_back(T const& value) [[ensures: back() == value]] ... }; In Boost.Contract (approach 1): template<typename T> class vector { void push_back(T const& value) { boost::contract::guard c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(back() == value); }) ; ... } }; Again, that might be what contract writes want in some case but in other cases they might want to just skip the assertion when T does not meet all the type requirements needed by the operations used in the assertion: template<typename T> class vector { void push_back(T const& value) [[ensures: static if(has_equal_to<T>::value) back() == value]] ... }; In Boost.Contract (approach 2): template<typename T> class vector { void push_back(T const& value) { boost::contract::guard c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT( boost::contract::check_if<has_equal_to<T>::value >( boost::bind(equal_to<T>, cref(back()), cref(value)) ) ); }) ; ... } }; --Lorenzo

1 0