- Boost - lists.boost.org

[CallableTraits] The formal review begins today
by Louis Dionne 13 Apr '17

13 Apr '17

Dear Boost community, The formal review of Barrett Adair's CallableTraits library begins today, April 3rd, and ends on April 12th. CallableTraits is a C++11 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, and removes the need for template specializations for different function signatures. You can find the documentation of the library here: http://badair.github.io/callable_traits/doc/html/index.html and the GitHub repository here: https://github.com/badair/callable_traits We encourage your participation in this review. At a minimum, kindly state: - Whether you believe the library should be accepted into Boost, and conditions for acceptance if any - Your name - Your knowledge of the problem domain You are strongly encouraged to also provide additional information: - What is your evaluation of the library's: * Design * Implementation * Documentation * Tests * Usefulness - Did you attempt to use the library? If so: * Which compiler(s)? * What was the experience? Any problems? - How much effort did you put into your evaluation of the review? We await your feedback! Regards, Louis

12 28

Formale Review: Callable Traits
by Peter Dimov 13 Apr '17

13 Apr '17

I think that the Callable Traits library should be ACCEPTED. The design of the library is sound, although I'm not fond of the ad-hoc metaprogramming part in "parameter list features". This is no fault of the author though, as without a modern type-metaprogramming library in Boost, everyone has to solve this problem in some way. Still, I think that most of these should be removed. Getting the arguments as a tuple that includes the class type as a first parameter raises the obvious question of void(foo::*)(float, char, int) -> tuple<foo&, float, char, int> void(foo::*)(float, char, int) & -> tuple<foo&, float, char, int> I understand why that is, but it still makes args lossy and the original can't be recreated from the tuple. Trailing varargs also have the same problem, as (float) and (float, ...) map to the same tuple. The obvious theoretically consistent approach here is void(foo::*)(float, char, int) -> tuple<foo, float, char, int> and void(float, ...) -> tuple<float, ct::varargs_t> which would be fully reversible but could possibly be less convenient in practice. I've a feeling that it might also be useful to provide an extractor that, for member pointers, returns just the arguments without the class. In "member qualifier features", I'm missing remove_member_cv_ref (obvious semantics) and copy_member_cv_ref (copies cv+ref from one member pointer to another.) In "member pointer features" we have the same problem in qualified_parent_class_of as in args, void(foo::*)() -> foo& void(foo::*)() & -> foo& It makes more sense for the first to yield 'foo', although this again may make the trait less convenient in practice. It would also _probably_ make sense to provide apply_qualified_member_pointer, which, given void(float) and foo const&, would yield void (foo::*)(float) const&. I did not look at the implementation. I ran the test suite on Windows under Cygwin g++ 5 in 11/14/1z, Cygwin clang 3.9 11/14/1z, msvc-14.0, msvc-14.1. The tests passed. Took a look at the tests themselves, the coverage looks excellent. The reference documentation is very good, although as already noted, it uses the terms of art "implementation defined" and "undefined behavior" incorrectly, this must be fixed. The non-reference portion is a bit thin. It would be improved considerably by presenting a few real-world use cases. All in all, a solid library that solves a real problem, even though the problem remains somewhat of a mystery for the uninitiated. :-)

4 4

Libraries and C++ compliance
by Edward Diener 12 Apr '17

12 Apr '17

I would like to ask people who present new libraries to Boost, in whatever stages they are, to please specify in the documentation to the library and/or in messages regarding the library, what level of C++ compliance is needed to use the functionality of that library. This plea is not being directed at any particular current library being mentioned by anyone on the mailing list, but is a general plea regarding developers and their efforts. I realize it is a real pain that C++ as a language, and as it continues to evolve, has a number of popular levels of C++ compliance. This is largely because C++ is offered by a number of different vendors in a number of different supported releases, each particular implementation supporting a number of levels of C++ compliance and sometimes only partially supporting a particular level of C++ compliance. But given this sometimes difficult situation I do not see it as enough for library docs/information to simply say "this library supports some-vendor/some-release" because this is actually fairly meaningless to me when I know that "some-vendor/some-release" supports a number of levels of C++ compliance through some compiler parameter ( often -std=something ). Therefore docs/information of "the library supports "some-implementation" or "the library is compliant with "more than one level of C++ compliance" tells me as much as if some one told me that the moon is yellow. So I am begging, pleading, entreating library authors to be specific about the C++ features or the C++ level of compliance needed to use their library, even if it is just a one-liner that succinctly explains what the end-user needs to know. Furthermore, for any given library could we please have specific information about what will happen if I use the library, or some feature of the library, without the desired minimum level of C++ compliance. While I would assume compile-time compiler errors as the norm another possibility, especially given the excellent support in Boost Config to compiler conformance, are more readable preprocessor errors. Finally a library might offer some level of advanced C++ compliance but fall back to a lower level if possible. Please, please library authors this is important. No end-user or tester of your library wants to spend extended time trying to figure out why some compile fails when the answer turns out simply to be one of inadequate C++ conformance level for a particular compiler implementation being used with a particular level of conformance.

13 29

Re: [boost] [proposed][histogram]
by Bjorn Reese 12 Apr '17

12 Apr '17

On 04/12/2017 11:37 AM, Hans Dembinski via Boost wrote: > The library implements a histogram class (a highly configurable policy-based template) for C++ and Python in C++11 code. Histograms are a standard tool to explore Big Data. They allow one to visualise and analyse distributions of random variables. A histogram provides a lossy compression of input data. GBytes of input can be put in a compact form which requires only a small fraction of the original memory. This makes histograms convenient for interactive data analysis and further processing. Given that the compression is lossy, I am wondering how it compares with a distribution estimator like: https://arxiv.org/abs/1507.05073v2 A common use-case when collecting numerical data is to determine the quantiles. Boost.Accumulators contains an estimator (extended_p_square) for that. The advantage of such estimators are that they execute in constant time and with constant memory usage, where the constant depends only on the required precision. PS: I am aware that this is a non-trivial question, so I do not expect an answer.

3 4

[proposed][histogram]
by Hans Dembinski 12 Apr '17

12 Apr '17

Dear Boost community, after another year of work, I hope to raise your interest once again in a much improved version of "histogram", a library proposed for inclusion in Boost. https://github.com/HDembinski/histogram http://blincubator.com/bi_library/histogram-2/?gform_post_id=1582 The library can be build either with b2 or cmake. It compiles successfully with several versions of clang and gcc and has 99 % test coverage (the remaining 1 % are basically un-hittable branches). Boost-style documentation is available. The library implements a histogram class (a highly configurable policy-based template) for C++ and Python in C++11 code. Histograms are a standard tool to explore Big Data. They allow one to visualise and analyse distributions of random variables. A histogram provides a lossy compression of input data. GBytes of input can be put in a compact form which requires only a small fraction of the original memory. This makes histograms convenient for interactive data analysis and further processing. A histogram implements a quantisation of a space of input values. The space is divided into non-overlapping cells. Instead of remembering the exact values of a tuple in that space, one just increases a counter in the corresponding cell. This is the lossy compression, you only remember the count in the cell and not the original values. There are subtleties related to the counting if you want it to be safe and efficient. The library handles this for you. The standard policy implements intelligent counters which are fast, conserve memory, and are guaranteed to not overflow or get capped (capping happens when you use floating point numbers to count, like some implementations do). This is one of the two main feature of the library. The other main feature is that the library allows you to seamlessly create one or multi-dimensional histograms using various schemes to divide the input space. A so-called axis class handles the division into cells along each dimension. There are several ways how you might want to define the cells that divide the input space, and library offers you interesting options. For example, if one of your inputs is an angle, the library provides a special axis class for periodic input values. What's new: - Static polymorphism: The original version of the library solely used dynamic polymorphism to support different axis classes. This variant still exists, but the current version also allows you to use static polymorphism, implemented internally with boost::mpl and boost::fusion. This provides a speed-boost, which makes this library faster than the open-source competitors I tested (CERN's ROOT framework, the GSL, and numpy.histogram), in addition to the enhanced flexibility. - Arbitrary-precision counters: Counter overflow is now completely avoided by switching automatically to boost::multiprecision::cpp_int when the capacity of standard integer types is exhausted. - Extensibility: The library is now much more extensible and configurable. All relevant behaviour can be exchanged by using another (possibly user-defined) policy. The library provides default trade-offs that should work for almost everybody, but you can chose your own trade-offs. The new features were inspired by comments I got from the community. Now I am again at a point where I see the library in a very solid state. Best regards, Hans

1 0

[gsoc17] Help review Google Summer of Code proposals
by Niall Douglas 11 Apr '17

11 Apr '17

Dear Boost, Student proposals for Google Summer of Code are submitted, please help us decide which have the most merit. I have reduced the fifty something proposals submitted down to twenty seven which have some chance. To be able to view and rank the student proposals, please do the following: 1. Send to gsoc-admin(a)boost.org your Google login. We will invite you to view the student proposals on the Boost Google Drive. Until you receive the invitation email, you won't be able to view the proposals. 2. Go to https://goo.gl/forms/EVppdHsHMnjkcUoD3 which is a Google form where you can score the proposals. We have linked each proposal there to the Google Drive item and there you can rank a proposal between 1 and 5. Make sure you use the same email as your Google login in the form, otherwise we will ignore any forms submitted to prevent gaming the results. 3. Even if you can't rank all twenty seven proposals, try to do as many as you can and then PRESS SUBMIT at the end of the form (forgetting to press SUBMIT means we never get your rankings). The proposals are presented in random order per person so any work you do will be useful. 4. Please try to have your rankings done by Monday 10th. You may find reviewing the page at https://svn.boost.org/trac/boost/wiki/SoC2017 useful. 5. Finally, if you'd like to mentor any of the proposals, send to gsoc-admin(a)boost.org your Google login so we may invite you onto the Google website as a mentor. Many thanks in advance. Niall & Bryce

4 5

[Review Queue] SIMD Review on Hold -- Attn: wizards
by Michael Caisse 11 Apr '17

11 Apr '17

Hello Wizards - We need to postpone the review for Boost.SIMD while I compile answers to questions raised about the IP. I will report on my findings as soon as possible and either reschedule the review date or ask for the library to be removed from the queue. I apologize for the inconvenience and disruption of the queue. Take care - michael -- Michael Caisse Ciere Consulting ciere.com

1 0

[release] 1.64.0 post-beta merges
by Rene Rivera 11 Apr '17

11 Apr '17

The master branch is is now open for post-beta merges, but only as described in the Post-Beta Merge Policy. See < https://github.com/boostorg/boost/wiki/Release-Beta-Merge-Policy> -- The Boost Release Team

13 56

[simd] Hardware support
by Bjorn Reese 10 Apr '17

10 Apr '17

Boost.SIMD only supports x86. Are there plans for ARM NEON and/or MIPS SIMD? What does Boost.SIMD currently do on unsupported platforms? Revert back to SISD?

13 41

[flat_set] When to sort?
by Vladimir Batov 10 Apr '17

10 Apr '17

I've been using boost::container::flat_set with quite a success until recently when I profiled my app to see that 30-50% of the run-time was spent in insert() for a container of around 50,000 in size. So, I had to replace boost::container::flat_set with a vector variation which inserts as a vector (no sorting). However, when it is the time to call begin(), end(), find(), it sorts once. That shaved the mentioned overhead off. Say, one run is down from 17s to 10s and the likes. I wonder if that should be the boost::container::flat_set default behavior rather than sorting the underlying container with every insert(). After all, as a user I do not care if the underlying container is sorted... until I start using/traversing it, right? Or maybe I am missing something in boost::container::flat_set which already allows me to do something of that sort?

11 37