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

fixed pt binary lib
by Neal Becker 06 Aug '08

06 Aug '08

I have the beginning of a fixed-pt binary lib. Fixed-pt is popular in DSP applications. It is integer arithmetic, but keeping track of the binary pt. It is built on top of constrained_value. It is small, so I include it here:

8 22

variant invariant
by Emil Dotchevski 05 Aug '08

05 Aug '08

Reading boost::variant's documentation: "If any bounded type is nothrow default-constructible (as indicated by boost::has_nothrow_constructor), the library guarantees variant will use only single storage and in-place construction for every bounded type in the variant. Note, however, that in the event of assignment failure, an unspecified nothrow default-constructible bounded type will be default-constructed in the left-hand side operand so as to preserve the never-empty guarantee." Do I read correctly that in an attempt to assign one variant object to another, the left-hand object _might_ silently change its type? This makes it very difficult for the user to enforce some useful invariants for types that have boost::variant members, which in my mind is very important. Wouldn't it be better to guarantee that operator= either succeeds or doesn't change the observable state of the left-hand side operand, even at the cost of memory allocation? In that case the other behavior may still be provided through a separate function. Emil Dotchevski Reverge Studios, Inc. http://www.revergestudios.com/reblog/index.php?n=ReCode

7 18

Why I hate subversion
by Eric Niebler 02 Aug '08

02 Aug '08

U boost/indirect_reference.hpp U boost/parameter.hpp svn: In directory 'boost' svn: Can't move 'boost/.svn/tmp/foreach.hpp.2.tmp' to 'boost/foreach.hpp': Permission denied ericne@ericne-xps ~/boost/org/trunk $ svn up svn: Checksum mismatch for 'boost/.svn/text-base/enable_shared_from_this.hpp.svn-base'; recorded: '12d8c5183a709a7699c13b312073c36c', actual: 'c89a6b23045ff8c89d2de74213d1649a' Does this ever happen to anybody else? I get this random corruption of my local subversion repository about once a month. -- Eric Niebler Boost Consulting www.boost-consulting.com

11 15

[unnullable_ptr] Proposal for a new library
by Angel Tsankov 02 Aug '08

02 Aug '08

Hello, Is there any interest in a class template which acts like a pointer and guarantees at compile time and at no CPU or memory cost (except when a call to any of its methods is not inlined) that the pointer is not null? One of the applications that I have found for this template is in defensive programming to eliminate the chances that dereferencing a pointer will result in undefined behaviour (when the pointer is null). Using this template is superior to any alternative method (that I know) to achieve the same result, since: (*) it consumes no CPU (in contrast to null checks); (*) the class template instances are copy constructible and copy assignable (in contrast to references which can also be used to guarantee unnullability); (*) it is natively supported by the language and provides a 'real' guarantee (in contrast to 'design by contract'); (*) supports the natural syntax for access to the wrapped resource (in constrast to boost::ref). Regards, Angel Tsankov

13 35

[shifted_ptr] STL support works at 90% (...!)
by Phil Bouchard 02 Aug '08

02 Aug '08

I've finalized the ad extremum idea of STL support of smart pointers such as shifted_ptr which is a good example to use because of the distinct types it is using as pointer types (T *, shifted<T> *, shifted_allocator::pointer, etc.). I have 2 patch files that can be used as an example to add support for real smart pointers using Gcc's STL. These are located in the bits/ folder. These are Gnu related but I wanted to share this here for objectivity. I have added special contructors in shifted_ptr that takes raw pointers (T *) instead of the type safe shifted<T> *. This is temporary until I add the proper casts inside the STL code. What else? I simplified shifted_allocator and fixed abominable bugs in shifted_ptr created by these temporary constructors added. Now I'm pretty dang happy about it... There are still some I need to fix and some more are yet to be found but it should be much easier now. Once again I am using shifted_ptr_test2.cpp as my main test application. Later, -Phil

1 2

Possible library submissions: fuzzy logic library, new container
by Alex Shafir 01 Aug '08

01 Aug '08

I am trying to determine if there might be any interest in a couple of possible library submissions. Both ideas were very useful and instrumental for many C++ development projects that I was doing for the last years. The fuzzy logic library is a simple, pure C++, optimized for speed, practical implementation of the fuzzy logic calculations that DOES NOT attempts to comply with the FCL(Fuzzy Control Language) standard (like IEC 1131). It CANNOT load FCL files. Instead similar to the Boost Spirit framework it provides a syntax that enables fuzzy logic rules to be written exclusively in C++. Compiled fuzzy model specifications are immediately executable. A snippet of what this syntax currently looks like is at the end of this message. The other idea is the “sparse array” container. Working for securities trading industry I used it innumerable number of times. It is useful in situations where there is a set of entities identified by integer(unsigned) numbers. Most often the numbers are identity keys in a database, a protocol field ids, etc. The potential range of the numbers makes it impractical to use a C++ array or the STL <vector>. On the other hand the average percentage of the keys that are really used in an application relative to the potential range is often less then 5% and there are huge holes of unused keys between zero and max(used key). The data elements or pointers to objects are kept in a structure similar to a balanced B-tree. Elements are directly accessed by an index operator. Access involves only a few arithmetic and redirection operations. When storing a new element that is outside of the range provided by exiting data structure the structure bilds itself up extending the indes range enough to accommodate a new index value. Existing data are never physically moved like in the STL vector. So, all references/pointers/iterators referencing existing elements are never invalidated. Feel free to comment. Fuzzy model syntax sample: ======================================== #include "TestModel.h" using namespace Fuzzy; // test model definition TestModel::TestModel(string file): Model(file), angle(-1), velocity(-1), speed(-1) { // fuzzy variables definitions created by the base class (Fuzzy::Model) // Input/Output methods; Input/Output arguments are refs // to double scalar variables Var& Angle = Input(angle); Var& Vlcty = Input(velocity); Var& Speed = Output(speed); // membership functions definitions created by fuzzy variables // Term method; Term method takes curve name as an argument; // cureve names are defined in the Fuzzy::Model curve definition // file MemFun& AngleNegHigh = Angle.Term("AngleNegHigh"); MemFun& AngleNegLow = Angle.Term("AngleNegLow"); MemFun& AngleZero = Angle.Term("AngleZero"); MemFun& AnglePosLow = Angle.Term("AnglePosLow"); MemFun& AnglePosHigh = Angle.Term("AnglePosHigh"); MemFun& VlctyNegHigh = Vlcty.Term("VelocityNegHigh"); MemFun& VlctyNegLow = Vlcty.Term("VelocityNegLow"); MemFun& VlctyZero = Vlcty.Term("VelocityZero"); MemFun& VlctyPosLow = Vlcty.Term("VelocityPosLow"); MemFun& VlctyPosHigh = Vlcty.Term("VelocityPosHigh"); MemFun& SpeedNegHigh = Speed.Term("AngleNegHigh"); MemFun& SpeedNegLow = Speed.Term("AngleNegLow"); MemFun& SpeedZero = Speed.Term("AngleZero"); MemFun& SpeedPosLow = Speed.Term("AnglePosLow"); MemFun& SpeedPosHigh = Speed.Term("AnglePosHigh"); // these are the model rules; syntax is pretty strightforward; // rules look like operator >> where lhs is the condition and // rhs is the conclusion; // lhs and rhs have to be in parens if they contain more then // one term because of the c++ operators precedence rules; // conclusion may be a comma separated list of output terms // in parens ((AngleZero and VlctyZero)or(AnglePosLow and VlctyNegLow)or(AngleNegLow and VlctyPosLow)) >> SpeedZero; ((AngleZero and VlctyNegLow)or(AngleNegLow and VlctyZero)) >> SpeedNegLow; ((AnglePosLow and VlctyZero)or(AngleZero and VlctyPosLow)) >> SpeedPosLow; ((AngleZero and VlctyNegHigh)or(AngleNegHigh and VlctyZero)) >> SpeedNegHigh; ((AnglePosHigh and VlctyZero)or(AngleZero and VlctyPosHigh)) >> SpeedPosHigh; } TestModel::~TestModel() { } void TestModel::run(double a, double v, double &s) { // we assign scalar variables to class members angle = a; velocity = v; speed = s; // then run the model // it should be pretty fast as it all designed to preallocate // all the needed large objects in the model constructor Model::run(); // and assign the values of output variables s = speed; }

3 2

dll-path feature
by brook＠biology.nmsu.edu 01 Aug '08

01 Aug '08

It seems that I need to use the dll-path feature to add an -rpath directive to the linker when my boost libraries are installed. This seems to be described (mostly) fairly clearly at http://www.boost.org/boost-build2/doc/html/bbv2/faq/dll-path.html What is not clear is where the feature should be invoked. My attempt to modify Jamroot to add <dll-path> to the boost-install rule failed in the sense that not rpath information makes it into the installed libraries. (The rest of this snippet is the original.). rule boost-install ( libraries * ) { package.install install : <dependency>/boost//install-headers $(install-requirements) : # No binaries : $(libraries) : # No headers, it's handled by the dependency ; install stage : $(libraries) : <location>$(BOOST_STAGE_LOCATE) <dll-path>/path/to/add/via/rpath ; local c = [ project.current ] ; local project-module = [ $(c).project-module ] ; module $(project-module) { explicit stage ; explicit install ; } } So, how is one supposed to invoke the <dll-path> feature in order to have -rpath added to the linking of libraries during their installation? Thanks for your help. Cheers, Brook

3 4

[release] xpressive bug fix
by Eric Niebler 01 Aug '08

01 Aug '08

What are the chances that I'll be able to merge a bug fix to the release branch? This one: http://svn.boost.org/trac/boost/ticket/2157 just came in, and I've already fixed it on trunk. Assuming that the next cycle of the trunk tests don't show anything amiss, would I be permitted to merge the fix? The bug will not cause crashes, but it will lead to incorrect results when matching the end-of-line assertion ($) against internal line breaks, which is fairly common usage scenario. I have high confidence in the fix. These are the relevant changesets: http://svn.boost.org/trac/boost/changeset/47899 http://svn.boost.org/trac/boost/changeset/47901 -- Eric Niebler BoostPro Computing http://www.boostpro.com

2 3

1.36 documentation
by Daniel James 01 Aug '08

01 Aug '08

Hello everyone, Since the generated documentation isn't currently included in the snapshots, I've temporarily made it available here: http://www.calamity.org.uk/1.36/ Hopefully, the documentation should be integrated with the beta site soon after the beta release. Daniel

9 19

[swap] End-user allowed to add overloads to boost namespace?
by Niels Dekker - mail address until 2008-12-31 31 Jul '08

31 Jul '08

Is any end-user allowed to add her own overloads of existing Boost functions to the boost namespace? The boost::swap utility from Joseph Gauterin (recently moved to the trunk) allows the user to customize boost::swap for her class, by providing a swap function for her class within the namespace of the class. Internally boost::swap does the idiomatical "using std::swap; swap(left,right);", to allow finding such a user-provided swap function by argument-dependent lookup (ADL) <svn.boost.org/svn/boost/trunk/boost/utility/swap.hpp> Unfortunately some compilers don't fully supported ADL, as is shown by the mixed test results of swap/test/specialized_in_global.cpp and swap/test/specialized_in_other.cpp, at http://www.boost.org/development/tests/trunk/developer/utility-swap_.html ADL failures appear to occur for GCC 3.3.1 (PathScale), Intel C++ 8.1, MSVC 7.1 (2003), and Borland (up to 5.9.3). Once the boost::swap utility would be used by other Boost libraries, end users might want to add a custom overload of swap for their classes to the boost namespace. Especially when users would have to deal with lacking ADL support of their compiler. Would it be okay for them to do so? Or are there some moral objections, or technical issues, regarding a user-provided overload within the boost namespace? Kind regards, Niels PS Volodya, thanks for fixing swap/Jamfile.v2! -- Niels Dekker http://www.xs4all.nl/~nd/dekkerware Scientific programmer at LKEB, Leiden University Medical Center

6 14