July 2007 - Boost - lists.preview.boost.org

Proposed addition to the iterator library for iterating over all tuples.
by Alex Mendes da Costa 19 Jun '09

19 Jun '09

Hi folks: I quite often have to write code to do the following: Given N sequences, generate all the N-tuples s.t. the i'th element in each tuple is drawn from the i'th sequence. For example, if sequence S1 is { 1, 2, 3 } and sequence S2 is { 10, 20 }, I need to generate these tuples: (1, 10), (2, 10), (1, 20), (2, 20). I think this problem could be solved elegantly with a iterator similar to zip_iterator. I have some questions: (1) Is there already a way to do this in boost? (2) If not, would this be a worthwhile addition to the iterator library? (3) If so, could I contribute code for this, or must the existing library owners write it? (4) If so, how would I go about getting my code added? Most of the docs seem to be about submitting entire libraries, rather than extensions to existing libraries. Thanks, Alex

4 18

[fusion] list/detail/at_impl.hpp, Suggest recrusive elem_at_c instead of recursive apply
by Larry Evans 24 Oct '07

24 Oct '07

In boost/fusion/.../list/detail/at_impl.hpp the apply is recursive; however, the only reason for the recursion is to "find the right element type". The other reason for apply is the same as that of the apply in.../vector/detail/at_impl.hpp. "find the right element type" in vector's at_impl is done with mpl::at. The similarity between list and vector at_impl would be more apparent if: template <typename Sequence, int N> struct elem_at_c { typedef typename mpl::eval_if< mpl::bool_<N == 0> , mpl::identity<typename Sequence::car_type> , elem_at_c<typename Sequence::cdr_type, N-1> >::type type; }; were used to find the right element type. Then the frist part of list::at_impl::apply would be: template <typename Sequence, typename N> struct apply { typedef elem_at_c<Sequence, N::value> element; typedef typename mpl::eval_if< is_const<Sequence> , detail::cref_result<element> , detail::ref_result<element> >::type type; which is very similar to the counterpart in vector: template <typename Sequence, typename N> struct apply { typedef mpl::at<typename Sequence::types, N> element; typedef typename mpl::eval_if< is_const<Sequence> , detail::cref_result<element> , detail::ref_result<element> >::type type;

2 3

[soc] Boost.extension/reflection project advances
by Mariano Gabriel Consoni 16 Oct '07

16 Oct '07

Hi Community...! As some of you may know, I'm working on a SoC project called "Boost.extensions and reflection". This mail is just to keep you informed about the project advances. At this time, we have very good news. The library is now near completion, and we expect submitting it for revision in the next days. We've been worked the last two weeks in the following tasks: - Code style: continued improving the code style according Boost guidelines. - Build: improved the Jamfiles to work well in more platforms. - Boost::function: migrated some code to (optionally) use boost::function. - Benchmarks: made new benchmarks to test the new integrations. - Performance analysis: documented the results of the benchmarks. - Preprocessor: replaced a lot of boiler-plate code with (optional) boost::preprocessor macros. - Dependencies flags: documented the optional dependencies and how to enable them. As I have finished all the tasks planned in my proposal (and a lot more :) ) I will advance to Reflection part and Jeremy (Pack, original author) will finish some remaining tasks of Extension. Bye! -- Mariano

4 6

[ANN] Xpressive 2.0 pre
by Eric Niebler 12 Oct '07

12 Oct '07

It's a poorly kept secret that I've been adding new features to Xpressive on CVS HEAD for a while now. So here are the features already implemented (documentation forthcoming) for Xpressive 2.0: << Semantic Actions >> Specify code to execute when parts of a regex match, a-la Spirit's semantic actions. Eg.: if you want to parse a string of name/value pairs into a std::map, you might: std::map<std::string, int> result; std::string str("aaa=>1 bbb=>23 ccc=>456"); // Like "(\\w+)=>(\\d+)": sregex pair = ( (s1= +_w) >> "=>" >> (s2= +_d) ) [ ref(result)[s1] = as<int>(s2) ]; sregex rx = pair >> *(+_s >> pair); if(regex_match(str, rx)) { assert(result["aaa"] == 1); assert(result["bbb"] == 23); assert(result["ccc"] == 456); } The actions are placed on a queue and executed in order only when the regex match succeeds. << Custom Assertions >> Use the check() function to create a boolean predicate that can participate in the match. Here's a regex that recognizes two integers only if the first is less than the second: sregex rx = ( (s1= +_d) >> ' ' >> (s2= +_d) ) [ check( as<int>(s1) < as<int>(s2) ) ]; Unlike actions, predicates execute immediately. You can also define the predicate out-of-line as a function object. << Dynamic Regex Grammars with Named Regexes >> Using regex_compiler, you can map a name to a regex object, and then refer to that regex from another by name. In this way, you can build grammars from regexes at runtime. sregex_compiler comp; sregex rx = comp.compile("^bar(?$RE)baz$"); comp.compile("(?$RE=)\\d+ \\d+"); There's an alternate syntax for associating a name with a regex that you can use to nest a static regex in a dynamic one. Eg., the last line above could be: comp["RE"] = +_d >> ' ' >> +_d; With these changes, you can now nest static and dynamic regexes within each other freely, giving you lots of flexibility to build grammars and modify them on the fly. << Named Captures >> For dynamic regular expressions, you can create a named capture with (?P<name> ...). You can refer back to the named capture with (?P=name). In substitution strings (for use with regex_replace()), you can refer back to a named capture with \\g<name> when using the format_perl or format_all flags. And more .... I'd like to give props to Dave Jenkins who has been doing m4d things with this stuff already, and who has given me a laundry list of other features he'd like. The new features are only available in CVS HEAD, for now. Feedback is welcome. -- Eric Niebler Boost Consulting www.boost-consulting.com

3 7

Variable Preprocess Metaprogramming?
by Atry 20 Sep '07

20 Sep '07

As we known, there is a preprocess metaprogramming library in boost, but it is not flexible enough. we are unable to define an custom preprocess loop(something like #for or #while ?), and we are also unable to use recursion. I have an idea to do that, C/C++ allows recursion of #include, so we can put the codes we want to evaluate repeatedly to a head, and include itself depends on a preprocess condition. But if we wrote code below, we would meet a error of macro redefinition. /**** foo.hpp ****/ #if FOO < 10 // do something with I # define FOO FOO + 1 # include "foo.hpp" #endif /**** foo.hpp ****/ /**** bar.hpp ****/ #define FOO 0 #include "foo.hpp" /**** bar.hpp ****/ The problem is that an macro must not depends on itself. Thus, to change a preprocess variant, I use a bit of #if to transfer value of a macro to some temporary macro. see my code below: /**** begin_set_value.hpp ****/ #if (BOOST_VPP_VALUE & (1 << 0)) == 0 #define BOOST_VPP_TEMPORARY_BIT_0 0 #else #define BOOST_VPP_TEMPORARY_BIT_0 1 #endif #if (BOOST_VPP_VALUE & (1 << 1)) == 0 #define BOOST_VPP_TEMPORARY_BIT_1 0 #else #define BOOST_VPP_TEMPORARY_BIT_1 1 #endif /* ... */ #if (BOOST_VPP_VALUE & (1 << 30)) == 0 #define BOOST_VPP_TEMPORARY_BIT_30 0 #else #define BOOST_VPP_TEMPORARY_BIT_30 1 #endif #if (BOOST_VPP_VALUE & (1 << 31)) == 0 #define BOOST_VPP_TEMPORARY_BIT_31 0 #else #define BOOST_VPP_TEMPORARY_BIT_31 1 #endif #undef BOOST_VPP_VALUE #define BOOST_VPP_VALUE \ (BOOST_VPP_TEMPORARY_BIT_0 << 0 ) \ + (BOOST_VPP_TEMPORARY_BIT_1 << 1 ) \ + (BOOST_VPP_TEMPORARY_BIT_2 << 2 ) \ + (BOOST_VPP_TEMPORARY_BIT_3 << 3 ) \ /* ... */ \ + (BOOST_VPP_TEMPORARY_BIT_29 << 29 ) \ + (BOOST_VPP_TEMPORARY_BIT_30 << 30 ) \ + (BOOST_VPP_TEMPORARY_BIT_31 << 31 ) \ /*BOOST_VPP_VALUE*/ /**** begin_set_value.hpp ****/ Now, the BOOST_VPP_VALUE is depends on some of BOOST_VPP_TEMPORARY_BIT_n, and can be used to change the former macro: #define FOO 0 #define BOOST_VPP_VALUE FOO #include "begin_set_value.hpp" #undef FOO #define FOO (BOOST_VPP_VALUE + 1) But, FOO depends on BOOST_VPP_TEMPORARY_BIT_ns, and can not be change again, the solution is that A must a variant depends on some other BIT_n definition instead of directly depends on BOOST_VPP_VALUE. Actually, I implements an variant stack to allocate and release these variant. I think the concept of variable preprocess is useful, if Boost.Typeof or Boost.Bind use that, these code they need would be less than copying same codes. I have upload a sample on vault, file name is variable_preprocess.zip. http://boost-consulting.com/vault/index.php?&direction=0&order=&directory=P… http://boost-consulting.com/vault/index.php?action=downloadfile&filename=va… All code is validated by wave, thank you for your attention.

6 12

[proto]context interface allowing "packaged" node args?
by Larry Evans 27 Aug '07

27 Aug '07

Hi Eric, I need a context with something like the following methods: template< typename Tag, typename Left, typename Right > result_type operator()(expr<Tag, Left, Right> const &expr) const { std::cout<<std::setw(indent) <<""<<"binary_expr:"<<expr.get_instance()<<"\n"; indent+=2; proto::eval(left, *this); proto::eval(right, *this); indent-=2; } where the expression tree node argument remains "packaged": (expr<Tag, Left, Right> const &expr) in contrast to the unpacked version: (Tag, Left const &left, Right const &right) shown in, for example: http://boost-sandbox.sourceforge.net/libs/proto/doc/html/boost_proto/user_s… IOW, the calculator.html page suggests an interface like: template< typename Tag, typename Left, typename Right > result_type operator()(Tag, Left const &left, Right const &right) const { std::cout<<std::setw(indent)<<""<<"binary_expr\n"; indent+=2; proto::eval(left, *this); proto::eval(right, *this); indent-=2; } where there's no access to the "packaged" extended node, expr<Tag,Left,Right>, where the extension is, for example: struct xmpl_domain; struct xmpl_delta { unsigned const my_instance; static unsigned our_instances; xmpl_delta(void) : my_instance(++our_instances) {} xmpl_delta(xmpl_delta const&) : my_instance(++our_instances) {} void operator=(xmpl_delta const&) {} unsigned get_instance(void)const { return my_instance; } }; unsigned xmpl_delta::our_instances=0; template<typename Expr> struct xmpl_expression : proto::extends<Expr, xmpl_expression<Expr>, xmpl_domain> , xmpl_delta { ... }; I've looked at the formated output of the preprocessed context.hpp; however, I'm still having difficulty figuring out if this "packaged" method interfaces is possible. Any help is appreciated. TIA. -regards, Larry

4 12

[range] range library proposal implementation rev.2
by shunsuke 26 Aug '07

26 Aug '07

Hi, all A new version of Oven, a range library proposal implementation, has been uploaded to Boost.Vault/Algorithm. The file: http://tinyurl.com/2axp2l Range Library Proposal: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1871.html An example "infinite sequence of factorials": void test() { BOOST_AUTO(factorials, expression(counting(1, max_count)|scanned(1, regular(lambda::_1 * lambda::_2))) ); int const answer[] = { 1,1,2,6,24,120,720,5040,40320,362880 }; BOOST_CHECK( equals(factorials|taken(10), answer) ); } This library is highly preliminary, but moderately tested. Any feedback appreciated. Regards, -- Shunsuke Sogame

2 12

[BGL] Tools for planar graph testing/embedding/drawing in the vault
by Aaron Windsor 21 Aug '07

21 Aug '07

Hi all, I've implemented a small suite of tools for dealing with planar graphs and would like to add it to the BGL. The core of this suite is built around the recent Boyer-Myrvold algorithm for planarity testing/embedding. (see http://www.emis.de/journals/JGAA/accepted/2004/BoyerMyrvold2004.8.3.pdf) A graph is planar if it can be drawn in two-dimensional space with no edge crossings. A graph is non-planar exactly when it contains a subgraph that is an expansion of one of two special subgraphs, called "Kuratowski subgraphs." This face makes it possible not only to detect that a graph is non-planar, but to prove it's non-planar by isolating one of these subgraphs. In addition to the obvious applications to graph-drawing, planar graphs are often simpler to deal with in optimization problems, and many problems that are NP-complete (most likely requiring exponential time to solve) have efficient algorithms or better approximation guarantees for the special case of planar graphs. The functions I've implemented allow one to: - Test a graph for planarity. - Embed a planar graph in the plane. - Find and verify a minimal Kuratowski subgraph in a non-planar graph. - Create a straight-line drawing of a planar graph (a mapping of vertices to points in the plane such that all edges can be drawn with straight line segments). - Traverse the faces of a planar graph using generic visitor event points in the spirit of the BGL depth-first and breadth-first search algorithms. With appropriate visitors, this traversal can be used to count the faces of a planar graph, triangulate a planar graph, or find a dual of a planar graph, among other things. With a few caveats about the efficiency of vertex index maps, etc. all of the functions above run in linear time with respect to the number of vertices in the graph, which is optimal. I've put two sets of files in the vault under Home/Algorithms/graph: the first is called planar_graphs.zip (also planar_graphs.tar.gz) and contains the .hpp files, the documentation, and the examples. The second is called planar_graph_testing.zip (also planar_graph_testing.tar.gz) and contains over 1000 test graphs and a small program that can be compiled to give an example of how these planar graph tools can be used. I'd appreciate any comments! Regards, Aaron

5 18

[Ann] Variadic Templates
by Doug Gregor 20 Aug '07

20 Aug '07

Hello Fellow Boosters, I have just completed implementing support for "Variadic Templates" in GCC. Variadic templates are C++ templates that can accept any number of "extra" template arguments, just like a function that uses C-style varargs (with "...") can accept any number of extra arguments. Unlike C varags, however, variadic templates work both for class templates and function templates, and are completely type-safe. Why do variadic templates matter for Boost? For one thing, they will allow us to eliminate the use of preprocessor metaprogramming in many, many places throughout the library. This can simplify our library implementations drastically, and eliminate those annoying "caps" on the number of arguments one can use (ever tried to use bind () with 11 arguments?). Beyond that, variadic templates are just plain fun, and there are undoubtedly a great number of metaprogramming applications. Here are a few teasers to illustrate what variadic templates can do: We can implement an MPL-like type vector with one line of code: template<typename... Types> struct vector { }; The "ellipsis" means that we can pack any number of arguments into the "template parameter pack" called Types. Of course, we can do the same for MPL's vector_c: template<typename T, T... Values> struct vector_c { }; Unimpressed? Here's an implementation of tuple that accepts any number of element types: template<typename... Values> class tuple; template<> class tuple<> { }; template<typename Head, typename... Tail> class tuple<Head, Tail...> : private tuple<Tail...> { protected: Head m_head; }; We're using recursion to build up the tuple. The ellipsis operator works with partial specializations, too, packing together "extra" arguments at the end. Of course, all of this would be useless if we couldn't write some of the other tuple operations, like operator==: inline bool operator==(const tuple<>&, const tuple<>&) { return true; } template<typename T, typename... TTail, typename U, typename... UTail> bool operator==(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u) { return t.head() == u.head() && t.tail() == u.tail(); } Variadic function templates can accept any number of function arguments, so we can now (finally!) implement a type-safe printf() without mangling the tried-and-true printf() syntax or restricting ourselves to POD types: void printf(const char* s) { while (*s) { if (*s == '%' && *++s != '%') throw std::runtime_error("invalid format string: missing arguments"); std::cout << *s++; } } template<typename T, typename... Args> void printf(const char* s, const T& value, const Args&... args) { while (*s) { if (*s == '%' && *++s != '%') { std::cout << value; return printf(++s, args...); } std::cout << *s++; throw std::runtime_error("extra arguments provided to printf"); } I've also built prototypes of of Function and Bind, among other things. The Bind example is especially interesting, and worth a read (see below) Interested? There is more information and a complete implementation in GCC available at: http://www.generic-programming.org/~dgregor/cpp/variadic- templates.html I've written two documents describing variadic templates in more detail: http://www.generic-programming.org/~dgregor/cpp/brief-intro.pdf : A brief introduction to variadic templates, that walks through the printf() implementation. http://www.generic-programming.org/~dgregor/cpp/variadic- templates.pdf : A complete proposal to introduce variadic templates into C++0x. This contains annotated versions of the tuple, function, and bind prototypes along with a detailed description of the capabilities of variadic templates. The GCC implementation is complete, supporting all of the features described in the proposal. I've used it for proof-of-concept implementations of several libraries. In the (near) future, I hope to introduce variadic templates support into the "official" GCC, but I need your help! Are variadic templates worthwhile? Will they help us build better, cleaner Boost libraries in the future? Should we bring variadic templates to the C++ committee, to enable better implementations of TR1 components and eliminate the need for much of the preprocessor metaprogramming we do today? Feedback is greatly appreciated. Cheers Doug Gregor Open Systems Lab @ Indiana University

20 39

[Important] Boost Subversion repository is now online
by Douglas Gregor 20 Aug '07

20 Aug '07

Hello all, The Boost Subversion repository is now back online. All of the files in CVS (including their histories) have been imported into the Subversion repository. CVS is still available for anonymous, read- only access for now, but will not be updated. The main Boost development branch is available via anonymous, read- only checkout at: http://svn.boost.org/svn/boost/trunk/ Or for developer read/write access at: https://svn.boost.org/svn/boost/trunk/ Information about accessing the Boost Subversion repository is available at: http://svn.boost.org/trac/boost/wiki/BoostSubversion Please report any problems to me to the main Boost list, and we will try to resolve them as quickly as possible. We still need help porting the regression-testing script over to use Subversion. See Trac ticket #1122: http://svn.boost.org/trac/boost/ticket/1122 Also, there is more documentation that will need to be updated within the Boost tree. - Doug Subversion tip: when you commit a change to Subversion that fixes ticket number NNN, include the text "Fixes #NNN" in your commit log. Trac will automatically close the ticket and cross-reference the commit with the ticket. See, for example, http://svn.boost.org/trac/ boost/changeset/38330

24 112

Boost building with CMake
by Bill Hoffman 17 Aug '07

17 Aug '07

Hi, I noticed the "boost development process / scope" thread on your list. A CMake user posted a link to your discussion. There is significant interest in the CMake community to help boost transition to CMake. Several people on the CMake list have volunteered to help, and Kitware is willing to put about 2 man weeks of effort into the conversion. I think that CMake has all the features to do what you need at this point, but if any bugs or issues are discovered during the process, we can fix them and/or provide work-arounds for the issues. I realize you have not yet decided on moving to CMake, but I thought I would put out this offer so that you could consider "free" support as one of the benefits you will receive from the port to CMake. I can see this happening in two ways. One would be for a CMake developer to create initial cmake files for boost, and get the basics working. Then, the work would be turned over to the Boost community. The other way would be to have a boost developer create the build files with help and support from the CMake community. Either way works for me. Of course, no one will want to do anything unless there is a commitment to actually use CMake. I will stay on this list while you decide, and answer any questions about CMake that may come up. Thanks, and I look forward to working with the boost community in the future. -Bill

47 194

proxies and const
by Eric Niebler 13 Aug '07

13 Aug '07

General design question here. This came up on the user's list, and it made me question something I believed to be true. When writing a proxy for, e.g., a std container, I see two options for handling const. 0) Const-ness depends on the const-ness of the object being proxied: struct vector_proxy { std::vector<int> & vec; typedef std::vector<int>::iterator iterator; typedef std::vector<int>::iterator const_iterator; iterator begin() const { return vec.begin(); } ... }; 1) Const-ness depends on the proxy object itself: struct vector_proxy { std::vector<int> & vec; typedef std::vector<int>::iterator iterator; typedef std::vector<int>::const_iterator const_iterator; iterator begin() { return vec.begin(); } const_iterator begin() const { return vec.begin(); } ... }; I think a loooong time ago, I preferred (1) but these days (0) is more natural for me, but I can't say why, exactly. Just feels like that's how it should be. Thoughts? FWIW, it came up in the context of BOOST_FOREACH's handling of proxies, so it's not (far) off-topic. -- Eric Niebler Boost Consulting www.boost-consulting.com The Astoria Seminar ==> http://www.astoriaseminar.com

7 16

[rfc] Boost Graphic/Game Engine
by Felipe Magno de Almeida 12 Aug '07

12 Aug '07

Hi, There were some little interest for this in another thread here in boost. So, who has any experience in game programming, it would be interesting to layout some requirements for a new engine and complaints from other engines. See if we can find out how a game engine should really be. Regards, -- Felipe Magno de Almeida

18 35

[svg_plot] Progress of SVG_Plot
by Jake Voytko 10 Aug '07

10 Aug '07

All, I have uploaded the newest version of SVG_Plot to the Boost Vault, and am looking for feedback. This library allows you to make 1 and 2 dimensional plots from STL containers, hopefully with minimal hassle :), and outputs the images as SVG files. The package contains 9 example files in project-root/libs/svg_plot/example that give a reasonable demonstration of what the library is capable of currently. The link to the library in the Vault is here: http://tinyurl.com/2mqvba And a link to online documentation is here: http://www.tcnj.edu/~voytko2/html/ It has been tested on Visual Studio 2005 and GCC 4.1.2. I'm looking for what you like about the library/documentation, and what you don't like (but please check the To Do list first to see if I'm aware of it!) The only extra issue is that because of some last minute trouble, I currently can't make 2D plots from 1D STL containers (vector, etc), but that will hopefully be fixed within the week. Thank you for your time, Jake P.S. If you need a program to look at the .SVG files, try either Firefox, IE with Adobe SVG plugin, or Inkscape.

6 11

Time Series review - 7/30-8/8
by John Phillips 10 Aug '07

10 Aug '07

My apologies for the delay in this posting, but the review period for the Time Series library submitted by Eric Neibler runs from Monday, July 30 until Wednesday, August 8. From the documentation: The purpose of the Boost.Time_series library is to provide data structures, numerical operators and algorithms to operate on time series. A time series is a series of data points, sampled at regular intervals. The library provides numerous time series containers, each with different time/space trade-offs, and a hierarchy of concepts which allow the time series to be manipulated generically. The library also provides operators and algorithms which use the generic interfaces to perform calculations on time series and accumulate various statistics about them. Boost.Time_series does not yet contain all the algorithms one might want in order to perform full time series analysis. However, the key contribution of Boost.Time_series is the framework and the rich hierarchy of concepts with which such algorithms can be written to efficiently and generically process series of data with widely divergent in-memory representations and performance characteristics. Boost.Time_series provides several such series containers, as well as mechanisms for defining additional series types and algorithms that fit within the framework. Some examples of series types that are provided are: dense, sparse, piecewise constant, heaviside and others, as well as adaptors for providing shifted, scaled and clipped series views. Please notice that the Time Series library uses some features of boost that will be part off the 1.35 release, but are not I the 1.34.1 release. For testing, you will need to either test against CVS Head (Which will not be available for much of Tuesday.) or use backports provided in the time series download files to update your 1.34.x installation. The library is available from http://boost-consulting.com/vault/index.php?directory=Math%20-%20Numerics or by following the link provided on the review schedule. Thanks to all for your time and effort on this review. John Phillips Review Manager

7 19

[Subversion] Subversion repository is now enforcing mime-types and eol-styles
by Douglas Gregor 10 Aug '07

10 Aug '07

Subversion handles end-of-line translation a bit differently from CVS. In Subversion, individual files need to be marked with both a mime-type and, for text files, an eol-style. These attributes determine how the Subversion client does end-of-line translation when communicating with the server. To maintain these properties requires some initial configuration of your Subversion client, described here under the "MIME types..." section: http://svn.boost.org/trac/boost/wiki/BoostSubversion The Subversion repository will verify that you have set the mime-type and eol-style properly when you try to commit, and will reject any commits that contain files without an appropriate MIME type. The configuration information above will automate the process of adding mime-types and eol-styles to new files, so the handling of end-of-line translation should be transparent in most cases. For more information about Subversion properties and how they are used with end-of-line translation, see: http://svnbook.red-bean.com/en/1.1/ch07s02.html - Doug

9 12

Submission to "Who's Using Boost?"
by Seweryn Habdank-Wojewódzki 09 Aug '07

09 Aug '07

Hi! I am using Boost library in Open Source library for Kohonen Neural Networks construction and training. I would like (if possible) join to famous list of Open Source users of the Boost library :-). * The name of the Application/Product/Service. Kohonen Neural Network Library (KNNL) * The name of the company (where appropriate). --- Personal initiative --- Authors: * Seweryn Habdank-Wojewódzki * Janusz Rybarski * A paragraph describing the Application/Product/Service. Kohonen neural network library is a set of classes and functions for design, train and use Kohonen networks (self organizing maps). * Any information you can provide about which parts of Boost you used, along with any comments you may have on how Boost helped your product development. KNNL Library requirements: * Boost Library ver. 1.33. o Core of library needs: + boost::bind, + boost::function, + boost::type_traits o Demonstration program uses: + boost::program_options * URLs to your companies home page, and the home page of the Application/Product/Service if there is one. http://knnl.sourceforge.net/ Best regards. -- |\/\/| Seweryn Habdank-Wojewódzki \/\/

2 1

[MD5] now in the vault
by Kevin Sopp 08 Aug '07

08 Aug '07

Hi all, I finished my own MD5 implementation today and decided to boostify it. It's not header only which is slightly inconvenient but Jamfiles, Docs and Tests are provided. Comments on the interface and other things are welcome! http://boost-consulting.com/vault/index.php?action=downloadfile&filename=md… just extract it to your boost directory and run 'bjam md5' regards, Kevin Sopp

5 8

[Boost][Interprocess] Lengthy test runtimes
by K. Noel Belcourt 08 Aug '07

08 Aug '07

Hi, The named_recursive test in boost.interprocess takes an excessive amount of time to run. Here you can see it's been running for 45+ minutes 13008 kbelco 25 0 14988 1360 1176 R 99.9 0.0 46:28.97 named_recursive 13014 kbelco 25 0 15040 1380 1188 R 99.8 0.0 46:10.09 named_recursive on fast hardware processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Xeon(R) CPU 5160 @ 3.00GHz Is there something wrong with this test, or my system? I'd like to request that this test be removed or somehow scaled back so it runs a bit faster. Is this possible? Thanks. -- Noel Belcourt

5 18

[x-files] the code's out there...
by Tobias Schwinger 03 Aug '07

03 Aug '07

Dear fellow Boosters, There is lots of useful, Boost-worthy utility code out there: Implementation details of existing / upcoming / (maybe even) proposed and rejected libraries that could stand alone, code on private hard disks never brought up for review, additions to existing libraries, etc. Fact is, that for small submissions the administrative overhead of (even) a formal (fast-track) review can be too high for developers' decency. Just imagine someone allocating five fast-track slots at once just for factoring out some unrelated bits of code from an existing library. So, why not group a bunch of unrelated utilities into a set of "Boost X-Files" and have them reviewed as a single library? It's completely non-intrusive to the review process and could seriously increase its efficiency. Like the idea? As a start, I stuffed my (tested and documented) "Boost candidate bits and pieces" into a common directory in the vault: http://tinyurl.com/35vlvb Feedback and more X-files welcome, of course. Regards, Tobias

3 6

[multi_index][ann][rfc] Preview of Boost.MultiIndex 1.35 release
by Joaquín Mª López Muñoz 03 Aug '07

03 Aug '07

Hello, I've uploaded a preview version of Boost.MultiIndex as planned for shipping with Boost 1.35 --I don't think there'll be time to include more major features. Download at the Vault: http://www.boost-consulting.com/vault/index.php?&direction=0&order=&directo… (file multi_index.zip) You can try the preview with Boost 1.34.x; if you want to test the newly added interoperability with Boost.Interprocess, you'll have to use a snapshot of Boost CVS, where this library currently lies. The new important features: * New global_fun predefined key extractor. * Added iterator_to facility. * Included support for non-standard allocators such as those of Boost.Interprocess, which makes multi_index_containers placeable in shared memory. Don't miss example #12 at the examples section, which fully exercises this new capacity. * New versions of modify and modify_key with rollback, as described in the tutorial. * Indices provide the new cbegin, cend and, when applicable, crbegin and crend member functions, in accordance with the latest drafts of the next revision of the C++ standard. A longer list of changes can be consulted at the release notes page. I'd be extremely grateful if you can try this preview version and report any problems you find. As we're still in time to discuss the new features, do not hesitate to comment on these and bring forward your proposals for improvement. Thank you very much for your interest in Boost.MultiIndex, Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

3 4

Cast free NULLs in algorithms
by Michael Marcin 02 Aug '07

02 Aug '07

Hello, I have something like: class A; boost::array<A*,10> the_array; std::fill( the_array.begin(), the_array.end(), NULL ); Which wont compile (at least under Visual Studio 2005) without a cast for NULL... I've had this problem before and decided to try to find an easy cast free expressive solution for it. After a few minutes I came up with: namespace detail { struct null_ptr_impl { template< typename T > operator T* () const { return static_cast<T*>(0); } }; } // end namespace detail const detail::null_ptr_impl null_ptr; std::fill( the_array.begin(), the_array.end(), null_ptr ); Does this exist somewhere already? Is it a good solution? Thanks, Michael Marcin

12 24

about: tutorial for using boost 'Unit Test Framework'
by Jagsir Singh 02 Aug '07

02 Aug '07

Hi All, I am sure, this might allready be answered here on the list. Is there a simple step by step tutorial for using the Unit Test Framework, and the bjam,(simplest jam file). It will be highly appreciated. Is there a searchable mailing list for boost some place ? in other words, --can you search through the mailing list archives ? -- /*/Jagsir /*/////////////

3 4

Boost Property Tree Status
by Eric Hill 01 Aug '07

01 Aug '07

I found the post on May 23, 2006 by Thorsten Ottosen saying that the Property Tree Library has been accepted into Boost. But I don't see it on the main Boost libraries page, rather just the sandbox entry for the original review. Does anyone know where Property Tree wound up? Eric

2 1

development branch(es)
by Stefan Seefeld 01 Aug '07

01 Aug '07

Hi there, with the 1.34.1 release out the door, what are the plans concerning the repository and the various branches ? Where should bug fixes and other patches go ? Is the release branch going to become the new development branch, as was suggested in a mail some moons ago ? Should I wait for the subversion migration before doing anything ? What is the timeframe for the migration ? Thanks for clarifying any of the above points. Regards, Stefan -- ...ich hab' noch einen Koffer in Berlin...

10 14