February 2009 - Boost - lists.preview.boost.org

Preview 4 of the Generic Geometry Library (ggl)
by Barend Gehrels 13 Mar '09

13 Mar '09

Dear list, It is a pleasure for us to present the fourth preview of the Generic Geometry Library. This time we've added the library to the SVN repository at boost, https://svn.boost.org/svn/boost/sandbox/ggl To store the library under a proper name, "ggl" is used, which stands for Generic Geometry Library. Before this we called it just Geometry Library, but we think Generic is appropriate from this version on. The first three previews were sent to this list in January, March and October 2008. Since then everything has been revised and reworked again, based on comments from the list. Thanks for all your comments! Concepts are now applied for all geometries. Algorithms now take any geometry fulfilling the concepts, and automatically take the right version of the underlying implementation. Ranges are now used instead of .begin()/end(). Tag dispatching is used instead of SFINAE. Transformations: previously these were just explained as an example, now transformations are included in the library, either to go from one coordinate system to another (for example from spherical to cartesian3D) or to translate/rotate/scale/map points from one Cartesian system to another, or otherwise. Map projections: included is an extensive addition with nearly 100 map projections. Those are not programmed by ourselves but automatically converted from C (PROJ4) into a our template-based approach, fitting with the geometry library, especially in the transformations explained above. License-wise this is possible. We're not sure about if this would fit in the Boost Library Collection, if there is interest in it, or that it might be "too much" for it, so we would be glad to hear your opinions. For more change descriptions, see the page on status and preview from the documentation (link below). The Generic Geometry Library is accessible from Boost SVN, mentioned above, or can be downloaded as well from http://geometrylibrary.geodan.nl Especially the examples, such as the custom point example and custom line string example show nicely how the library handles custom geometries and how they can be used inside the generic algorithms. We welcome any type of comment, opinion, cooperation, merge or join. Barend Gehrels, Amsterdam Bruno Lalande, Paris

3 11

[filesystem][cygwin] Standard conformance for wide characters
by Beman Dawes 11 Mar '09

11 Mar '09

I've decided not to attempt support for Cygwin in the next version of Boost.Filesystem. Cygwin's lack of library support for wchar_t is the problem . For the current Boost.Filesystem version (v2), the necessary workarounds are so pervasive that the implementation code is much harder to read and maintain. Witness the number of bug reports that are Cygwin specific. For v3, currently under development, trying to support Cygwin would be even harder, and would cause a serious delay in development. Plus I'm tired of waiting for the cygwin folks to come into full C++ conformance. IIUC, the reason Cygwin doesn't provide C++ standard library support for wchar_t is that the underlying C library is missing the C wchar_t functions. Perhaps Boosters who care about Cygwin could spearhead an effort to add the missing C support? The needed functionality isn't all that complex; the main problem might be just learning enough about how Cygwin/GCC is configured and built to be able to add a fairy small number of C functions. Thoughts? --Beman

10 29

Request for interest in the new Synchro library
by vicente.botet 10 Mar '09

10 Mar '09

Hi, I would like to know if the Boost community is interested in the Synchro library. Of course there is a lot of work to do, but I think that there is enough material to start a discussion on the approach. I'd appreciate it if people could take a look, test it on their compiler and give me some feedback. The library is available at Boost Sandbox: https://svn.boost.org/svn/boost/sandbox/synchro and Boost Vault: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=synchr… that iIncludes every thing on the Sandbox + Html documentation Some examples use Boost.Interthreads also (available on the vault and the sandbox). This library is a compilation of what I have found in the literature not yet present in Boost. My main concern has been to boostify all these ideas in a coherent way. Next follows an overview of the library features: Boost.Synchro provides: * A uniform usage of Boost.Thread and Boost.Interprocess synchronization mechanisms based on lockables(mutexes) concepts and locker(guards) concepts. o lockables traits and lock generators, o lock adapters of the Boost.Thread and Boost.Interprocess lockable models, o locker adapters of the Boost.Thread and Boost.Interprocess lockers models, o complete them with the corresponding models for single-threaded programs: null_mutex and null_condition classes, o locking families, o semaphore, o condition_lockable lock which put together a lock and its associated conditions. * A coherent exception based timed lock approach, * A rich palette of lockers as o strict_locker, nested_strict_locker, o condition_locker, o reverse_locker, nested_reverse_locker, o locking_ptr, on_dereference_locking_ptr, o externally_locked, * A polymorphic lockable hierarchy. * High-level abstractions for handling more complicated synchronization problems, including o monitor for guaranteeing exclusive access to an object, and o a so-called rendezvous mechanism for handling direct communication between objects concurrent_components via ports using an accept-synchronize protocol based on the design of the concurrency library in the Beta language. On going work * array_locker and tuple_locker locker containers. * A complement to the already present in Boost.Thread lock, try_lock free functions: o lock_until, lock_for, try_lock_until, try_lock_for Best regrads, Vicente Juan Botet Escribá

3 12

wiki.boost.org Ancient
by Joel 09 Mar '09

09 Mar '09

Can wiki.boost.org be redirected to someplace useful? Right now it is an advertisement for crystal clear software. It is a bad advertisement since it is from 2005. Even worse, it has a link to a "boost wiki" that isn't being updated and has spam hidden away in it. It claims not to be official, but if the url is wiki.boost.org, it IS official! Thanks! Joel

4 6

[optional] little addition
by Arno Schödl 07 Mar '09

07 Mar '09

I just started using boost::optional, and this proved to be generically useful, but I believe is currently not in boost::optional: template< class T, class Tcompatible > bool optional_assign( T& t, boost::optional<Tcompatible> const& optt ) { if( optt ) { t=*optt; return true; } else { return false; } } so you can write boost::optional< TMyValue > TryToGetT(); T t; if( !optional_assign( t, TryToGetT () ) { ... other way to get t ... } instead of the more verbose: boost::optional< TMyValue > TryToGetT(); T t; boost::optional< TMyValue > const& optt=TryToGetT(); if( optt ) { t=*optt; } else { ... other way to get t ... } get_optional_value_or is similar, but the alternative must be an expression and is eagerly evaluated, both of which may be undesirable. Arno -- Dr. Arno Schoedl · aschoedl(a)think-cell.com Technical Director think-cell Software GmbH · Invalidenstr. 34 · 10115 Berlin, Germany http://www.think-cell.com · phone +49-30-666473-10 · toll-free (US) +1-800-891-8091 Directors: Dr. Markus Hannebauer, Dr. Arno Schoedl · Amtsgericht Charlottenburg, HRB 85229

4 23

[1.38.0] PDF package of Boost documentation released.
by John Maddock 07 Mar '09

07 Mar '09

Folks, A package containing PDF versions of Boost's documentation is now available for Boost-1.38.0 from the usual sourceforge download site: http://sourceforge.net/project/showfiles.php?group_id=7586&package_id=15971… Please note that due to the diverse range of tools in use within Boost it has not been possible to produce PDF's for all of Boost's libraries, those currently included as PDF's are: accumulators any array asio bimap range complex-tr1 concepts config conversion date_time foreach function hash interprocess intrusive iterator math-gcd math mpi octonion optional phoenix program_options proto python_tutorial quaternion ref regex scope_exit signals static_assert string_algo thread tr1 tribool type_traits typeof units unordered variant xpressive Documentation for the following tools are also included in this package: bjam boost_build boostbook quickbook Regards, John Maddock.

6 9

Formal Review: Boost.RangeEx
by Thorsten Ottosen 06 Mar '09

06 Mar '09

Dear Developers and Users, It's my pleasure to announce that the review of Neil Groves' RangeEx library starts today and lasts until March 3, 2009. What is it? +++++++++++ The library provide two very useful extensions to the range library 1. Range-based algorithms. E.g. boost::sort( rng ); which is a convenient wrapper of instead of std::sort( boost::begin(rng), boost::end(rng) ); But the new interface also allows for more expressive code because (on the fly) composition of algorithms suddenly is possible. 2. Range adaptors. E.g. std::vector<int> vec = ...; boost::copy( vec | boost::adaptors::reversed, std::ostream_iterator<int>( std::cout ) ); where the expression "vec | boost::adaptors::reversed" wraps the iterators of the range on the left in reverse iterators. The library provides a wide range (no pun intended) of Range adaptors, and they are a powerful way to create ranges on the fly and pass them to algorithms. Getting the library +++++++++++++++++++ The library may be downloaded from http://www.cs.aau.dk/~nesotto/boost/range_ex.zip or from the Boost vault under "Algorithms". The docs may be browsed online here http://www.cs.aau.dk/~nesotto/boost/libs/range/ Please note that the documentation is integrated with the current Range ilbrary. Therefore the relevant sections for the review is http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/adaptors.html and http://www.cs.aau.dk/~nesotto/boost/libs/range/doc/algorithms.html The code may be browsed here: http://www.cs.aau.dk/~nesotto/boost/boost/range/ Notice the library is header only (exception: the adaptor tokenized() depends on Boost.Regex). Writing a review ++++++++++++++++ If you feel this is an interesting library, then please submit your review to the developer list (preferably), or to the review manager. Here are some questions you might want to answer in your review: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick - reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Special considerations ++++++++++++++++++++++ Various RangeEx like libraries have been implemented in the past. You might want to compare with those libraries when you form your oppinion: 1. John Torjo's range lib http://rangelib.synesis.com.au/libs/boost-rangelib-20040913.zip http://torjo.com/rangelib/index.html 2. Adobe's ASL libraries include range-based algorithms: http://stlab.adobe.com/group__algorithm.html I'm looking forward to your review. best regards Thorsten, Review Manager

18 101

BGL question about districting
by Barend Gehrels 06 Mar '09

06 Mar '09

Hi, We're about an automated districting tool. We want to create Y districts from X polygons, all having a specific value (e.g. area or inhabitants), where the total value of each district is as similar as possible and each district is also as similar as possible. Let's call the value the "potential". Of course this problem is NP-hard so we're glad with the first solution or e.g. the first ten solutions. We thought to implement this by the Boost Graph Library. First we detect neighbour relations with our own Geometry Library (using the still-to-build "touches" relationship). We've a graph then and can divide the graph into subgraphs, each having connected nodes and an (nearly) equal "potential". I've some experience with BGL, having used the "connected_components". But I cannot find an appropriate algorithm for this problem, if it is available. Actually it even could be a "network flow" algorithm dividing the total potential by Y, and starting at some point flowing the potential through the graph. But all network flow algorithms seem to be on directed graphs. This is an undirected graph. It it is not possible with a standard BGL algorithm I think we can still solve it using BGL and e.g. breadth-sort-first, but just want to verify if it is possible or maybe by an unexpected workaround. Thanks, Barend

4 5

[time series] What happened to this library?
by Christian Henning 05 Mar '09

05 Mar '09

Hi there, as far as I can tell this lib has been approved but it doesn't show up in boost. Why is it not in there? Thanks, Christian

11 21

Design conventions; passing functors
by Joachim Faulhaber 04 Mar '09

04 Mar '09

Hi, I am pondering about functor passing. Functors occur in my library (ITL) e.g. for the aggregation of associated values on insertion in interval_maps (aggregation on overlap): template<class Domain, class Codomain, ...> class interval_map{ ... //(1) My current implementation is this: // Combinator is the aggregating functor template, // instantiated at compiletime template<template<class>class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator template passed or instantiated somewhere*/ } ... } //I like this definition, because it's abstract: // The functor has to be a matching template e.g. inplace_max interval_map<int,int> m; m.add<inplace_max>(some); //(1) template<class Domain, class Codomain, ...> class interval_map{ //(2) The more traditional definition template<class Combinator> interval_map& add(const value_type& value_pair) { /*Combinator type passed or called somewhere*/ } ... m.add<inplace_max<int> >(some); //(2) I prefer (1) but both definitions (1) and (2) are purely static denotations. To have adaptable functors or functors that can have states, like in ... m.add(some, max_under(42)); ... I am afraid I have to say sayonara to definition (1) and use this instead: template<class Domain, class Codomain, ...> class interval_map{ //(3) Adaptable functor template<template<class>class Combinator> interval_map& add(const value_type& value_pair, const Combinator<Codomain>& combine) { /*combine functor passed or called somewhere*/ } Now, there seems to be a convention from the STL that functors shall be passed BY VALUE. template<template<class>class Combinator> interval_map& add(const value_type& value_pair, Combinator<Codomain> combine); This is stated in [Sutter & Alexandrecu 2005, C++ Coding Standards] item 89: "Function objects are modeled on function pointers. Like function pointers, the convention is to pass them by value. All of the standard algorithms pass objects by value, and your algorithms should too." I do not really understand this convention and feel some resistance to follow it. In addition the call by value implementation can (and will) lead to heavy inefficiency by unaware usage of fat functors. So I browsed through some boost libraries and found that functors are passed by reference there (e.g. accumulators, fusion). Final question: What is the boost standard on passing functors, that I can adapt to? Cheers Joachim

6 20