February 2006 - Boost-users - lists.preview.boost.org

How to bind the first of a pair?
by Meryl Silverburgh 23 Feb '06

23 Feb '06

I have a map with key is a pair: typedef map < pair<int, int>, string> pairMapString; pair<int, int> key(1,3); map[key] = "one"; How can I create a binary function using boost lamba which check the first value of the pair of the key of the map? void add(pairMapString;& myMap, int x) { iterator& itr = find_if(myMap.begin(), myMap.end(), bind(equal_to < int >(), bind(&BlockDataPairMap::value_type::first::value_type::first, _1 ) , x) ); }

6 11

filter_iterator and bind
by Nico Galoppo 23 Feb '06

23 Feb '06

Hi, I'm having trouble getting make_filter_iterator and bind to work together nicely: ------------------------------------------------------------------------------- boost::function<bool (const node_type&)> is_constraint; is_constraint = boost::bind(&node_type::IsConstraint, _1); boost::make_filter_iterator(is_constraint, ab.begin(), ab.end()); // ERROR: does not compile boost::make_filter_iterator(boost::bind(&node_type::IsConstraint, _1), ab.begin(), ab.end()); // compiles ------------------------------------------------------------------------------- Note that ab.begin()/ab.end() return iterators to containers of shared pointers. See below for compiler errors. What I would like to do, in the end, is something like this: ------------------------------------------------------------------------------- typedef boost::filter_iterator<boost::function<bool (const node_type&)>, articulated_model_type::node_df_traversal_iterator> joint_iterator; joint_iterator first = boost::make_filter_iterator(boost::bind(&node_type::IsConstraint, _1), ab.begin(), ab.end()); ------------------------------------------------------------------------------- Unfortunately, this doesn't compile either. I want an explicit handle to the interator (first), because I'd like to do a normal for loop like this: for(joint_iterator joint = first; joint != last; ++joint) { ... } Again, compile errors are below. Thanks for the help. --nico d:\dev\boost_1_33_1\boost\iterator\filter_iterator.hpp(100) : error C2664: 'boost::function1<R,T0,Allocator>::result_type boost::function1<R,T0,Allocator>::operator ()(T0) const' : cannot convert parameter 1 from 'Hybrid::Graph<node_traits>::const_node_ptr' to 'const Hybrid::Node<graph_type_,node_traits> ' with [ R=bool, T0=const Hybrid::Node<Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::graph_type,ArticulatedModelNodeTraits<MyTypes>> , Allocator=std::allocator<void> ] and [ node_traits=ArticulatedModelNodeTraits<MyTypes> ] and [ graph_type_=Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::graph_type, node_traits=ArticulatedModelNodeTraits<MyTypes> ] Reason: cannot convert from 'Hybrid::Graph<node_traits>::const_node_ptr' to 'const node_type' with [ node_traits=ArticulatedModelNodeTraits<MyTypes> ] No constructor could take the source type, or constructor overload resolution was ambiguous d:\dev\boost_1_33_1\boost\iterator\filter_iterator.hpp(99) : while compiling class-template member function 'void boost::filter_iterator<Predicate,Iterator>::satisfy_predicate(void)' with [ Predicate=boost::function<bool (const node_type &)>, Iterator=Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::node_df_traversal_iterator ] d:\dev\Hybrid\Tests\Graph\main.cpp(645) : see reference to class template instantiation 'boost::filter_iterator<Predicate,Iterator>' being compiled with [ Predicate=boost::function<bool (const node_type &)>, Iterator=Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::node_df_traversal_iterator ] ====================================================================================== :\dev\Hybrid\Tests\Graph\main.cpp(646) : error C2440: 'initializing' : cannot convert from 'boost::filter_iterator<Predicate,Iterator>' to 'boost::filter_iterator<Predicate,Iterator>' with [ Predicate=boost::_bi::bind_t<bool,boost::_mfi::cmf0<bool,ConstraintNodeTraits>,boost::_bi::list1<boost::_bi::list_av_1<boost::arg<1>>::B1>>, Iterator=Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::node_df_traversal_iterator ] and [ Predicate=boost::function<bool (const node_type &)>, Iterator=Hybrid::Graph<ArticulatedModelNodeTraits<MyTypes>>::node_df_traversal_iterator ] No constructor could take the source type, or constructor overload resolution was ambiguous -- nico galoppo von borries @ address: 105 creel st., chapel hill comp. graphics phd. student @ north carolina, 27516 USA UNC, chapel hill @ phone: +1 (919) 962-1898 (office) @ +1 (919) 942-7609 (home) @ email: nico at cs dot unc dot edu @ homepage: http://www.cs.unc.edu/~nico --- debian linux :: vim powered

7 15

date-time library question
by Albert Wessel 23 Feb '06

23 Feb '06

Hello, How can I get a localized date string with the boost date / time library? To illustrate: date d(2005,06,25); string sometext=to_simple_string(d); This returns: 2005-Jun-25 However, I want to be able to define my own formats.I can get the localization example to work and format my stuff on stdout, but nowhere it tells anything about how to fill in a string using localized settings. Thank you, Albert

4 5

Re: [Boost-users] [bind] Generic loop with generic algorithmchickenand egg signature problem
by Nat Goodspeed 23 Feb '06

23 Feb '06

From: boost-users-bounces(a)lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Antonio Piccolboni Sent: Wednesday, February 22, 2006 7:15 PM To: boost-users(a)lists.boost.org Subject: Re: [Boost-users] [bind] Generic loop with generic algorithmchickenand egg signature problem Thanks Peter, but it does not. Error message bind_test.cpp: In function 'int main()': bind_test.cpp:33: error: no matching function for call to 'bind(<unknown type>, const boost::lambda::lambda_functor<boost::lambda::placeholder<1> >&, const boost::lambda::lambda_functor<boost::lambda::placeholder<2> >&, int)' This also dooms my theory of why this doesn't work since the explicit instantiation of the accumulate template should provide the necessary information. On 2/22/06, Peter Dimov <pdimov(a)mmltd.net> wrote: Antonio Piccolboni wrote: [...] > int main() { > std::vector<int> d; > std::vector<std::vector<int> > s; > loop_func(s.begin(), s.end (), d.begin(), > BinFunc()); //flies with gcc > loop_func(s.begin(), s.end(), d.begin(), > bind<int>(std::accumulate, _1, _2, 0.0)); //does not bind( std::accumulate< std::vector<int>::iterator, int >, _1, _2, 0 ) [Nat] Umm, parentheses() after the std::accumulate template params?

1 0

[bind] Generic loop with generic algorithm chicken and egg signature problem
by Antonio Piccolboni 23 Feb '06

23 Feb '06

I have a vector of vectors or some nested data structure of that sort. I want to loop over the outer structure and summarize the inner structure, like taking averages of all the vectors or what not. Once I saw that in the code three times I thought it was time to abstract it out. So the plan was to have a generic loop function that takes a functor type for the action to perform inside the loop. So far so good. In many instances that action is a standard algorithm or composition thereof, so why not use functors like those returned by bind(accumulate, _1, _2, 0) instead of writing little polluting classes like BinFunc below? But the compiler is at a loss guessing the types, and it looks to me like it is for a good reason, because to instantiate the accumulate template it has to know the precise signature of my loop function and the converse too. Can the lambda experts shed light on this? It seems a quite natural use case. Thanks Antonio PS: in an ideal world the following example can be done combining transform call_begin and call_end, but that an whole different story #include <boost/lambda/lambda.hpp> #include <boost/lambda/bind.hpp> #include <vector> #include <numeric> #include <functional> using namespace boost::lambda; template<class Func, class NestedIt, class It> void loop_func(NestedIt start, NestedIt stop, It dest, Func f) { for(;start < stop; start++, dest++) { *dest = f(start->begin(), start->end()); } } class BinFunc: public std::binary_function<std::vector<int>::iterator, std::vector<int>::iterator, int> { public: int operator() (std::vector<int>::iterator b, std::vector<int>::iterator e) { return accumulate(b,e,0); } }; int main() { std::vector<int> d; std::vector<std::vector<int> > s; loop_func(s.begin(), s.end (), d.begin(), BinFunc()); //flies with gcc loop_func(s.begin(), s.end(), d.begin(), bind<int>(std::accumulate, _1, _2, 0.0)); //does not } bind_test.cpp: In function 'int main()': bind_test.cpp:32: error: invalid initialization of reference of type 'const int&' from expression of type '<unknown type>' /usr/include/boost/lambda/detail/bind_functions.hpp:532: error: in passing argument 1 of 'const boost::lambda::lambda_functor<boost::lambda::lambda_functor_base<boost::lambda::action<4, boost::lambda::function_action<4, boost::lambda::detail::unspecified> >, typename boost::lambda::detail::bind_tuple_mapper<const Arg1, const Arg2, const Arg3, const Arg4, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>::type> > boost::lambda::bind(const Arg1&, const Arg2&, const Arg3&, const Arg4&) [with Arg1 = int, Arg2 = boost::lambda::lambda_functor<boost::lambda::placeholder<1> >, Arg3 = boost::lambda::lambda_functor<boost::lambda::placeholder<2> >, Arg4 = double]'

2 3

Re: [Boost-users] Program option parsing
by Merrill Cornish 22 Feb '06

22 Feb '06

If you don't want a --help or -h on the command line, could you output the help text is the user doesn't provide exactly two positional arguments? Merrill

2 1

Program option parsing
by Calderon Hector 22 Feb '06

22 Feb '06

Hi all, I'm using <boost/program_options.hpp> to parse a command line. It has only two positional arguments. However, I don't see how to generate the help without the name of the variable. I'd like to get the following output: MyProg.exe Param1 [Param2] where Param1 is the first parameter Param2 (=200) is the second parameter (optional) Any ideas would be appreciated. Hector C. ---------------------------------- --------------------------------- Yahoo! Mail Use Photomail to share photos without annoying attachments.

1 0

[statechart] Asynchronous Machines
by David Greene 22 Feb '06

22 Feb '06

If I have an asynchronous state machine running in another thread and I send it an event, is there any way to have the sending thread block until the event is processed? I need to use an asynchoronous machine because the rest of my app is threaded but yet there are points where I must synchronize to know the machine is in a certain state before moving on. >From the documentation it seems like passing zero to FifoWorker::operator() (via fifo_scheduler::operator()) will do the trick, but I'm not sure. I've created a non-blocking asynchronous machine because the thread calling fifo_scheduler::operator() should not block if the queue is empty. It should process all events in the queue and return. Have I got that all correct? -Dave

3 12

Re: [Boost-users] [statechart] Asynchronous Machines
by Gottlob Frege 22 Feb '06

22 Feb '06

> > Date: Tue, 21 Feb 2006 19:03:11 -0600 > From: David Greene <greened(a)obbligato.org> > Subject: Re: [Boost-users] [statechart] Asynchronous Machines > To: boost-users(a)lists.boost.org > Message-ID: <43FBB84F.70305(a)obbligato.org> > Content-Type: text/plain; charset=us-ascii > > > Nowadays both CPUs tend to have caches. Whether or not the cache > > contents is guaranteed to be written back to the main memory when thread > > A returns depends on the architecture of your hardware. IIRC, on X86 > > architectures there is such a guarantee. On other architectures you > > might need to use mutexes or a similar concept to guarantee that thread > > B sees the updates of thread A. > > Mutexes don't effect cache coherence. Likely there will have to be > calls to special intrinsics depending on the architecture. Short Answer: Yes they do. Very long answer: More correctly the problem isn't really 'cache coherence' in the traditional meaning of cache coherency (which is that the cache, for your cpu, is consistent with main memory, etc), it is the order of memory reads and writes, and Mutex's are guaranteed to do whatever is necessary to make sure all queued reads are read before you get the mutex lock (ie they force a memory 'acquire' barrier) and they make sure all writes are written before the mutex is released (a 'release' memory barrier). The important example is this: Thread 1: bool object_is_contstructed = false; Object object(17); // construct it object_is_constructed = true; Thread 2: if (object_is_constructed) { use_object(object); } else dont_use_object(); // really we would probably wait, but this is an example Problem 1 (Thread 1) object_is_constructed may be set to true (in shared memory) BEFORE all the constructed bytes of object are seen in shared memory. This has NOTHING to do with compiler optimizations or 'volatile' or the OS or other stuff. It is the hardware. (And really, whether you think of this as cache coherency or read/write order or whatever doesn't matter much, as long as the rules and concepts make sense.) Problem 2: EVEN IF object_is_constructed is written AFTER object is constructed, Thread 2 might read object BEFORE reading object_is_constructed! (Similar stuff. Basically, think about how the processor wants to optimize the order of memory reads/writes so as to not jump around memory too much - similar to how disk drivers try to optimize read/writes to avoid seeks.) So what to do? In a sense, flush the reads/writes similar to what you would need to do for harddrives. Any and all thread primitives will do this for you implicitly. POSIX threads (pthreads) actually try to document this, but you can assume it for any thread library otherwise the library is essentially useless. So use locks. Look are writing first: lock mutex, write object, write object_is_constructed release a mutex. note that in whatever order object and is_constructed are actually written to main memory, they both are written before the release. ***the order of those writes CANNNOT come after the order of the writes inside the mutex*** because of the 'release' memory barrier inside the mutex release. Now on reading, lock mutex read is_constructed read object release mutex So the read of object might still come before the read of is_constructed, but you CANNOT read either of them before the read of the mutex. And the mutex was written in order, so everything stays in order. To take it a step further, if you had barrier control, you COULD do away with the mutex (if you wanted to spin lock, or just skip using 'object' as in the example) as so: Thread 1: write object release barrier write is_constructed the barrier prevents the object write to move below the barrier. Thread 2: read is_constructed (into temp) acquire barrier if (temp) read object the acquire barrier prevents the read of 'objecrt' to move above the acquire. Note that, for example, Win32 now has explicit barrier versions of its Interlocked functions ie InterlockedIncrementAcquire, etc. (The old ones, it can be assumed, did 'full' barriers.) Mac OSX has similar functions. x86 never re-orders writes, but it can re-order reads. The IA64 *spec* says it can reorder both, although the processor doesn't seem to. Conventional wisdom is that the spec is explicitly 'looser' so that they can loosen the implementation in the future. Oh, also, the are other refinements on the barriers - think of the combinations - are we only concerned about the order of reads w.r.t. other reads, writes with other writes? What about the order of reads vs writes, etc? Thus back to the short answer: mutexes et al, magically do what is necessary to make it work. Tony. P.S. hope I got all that straight. It is easy to mix up the names of the barriers relative to their direction and reads vs writes, etc. I tend to just remember the general principles.

2 1

[BGL]Repost? Problems in the shortest pair algorithms.
by Peter Gerell 22 Feb '06

22 Feb '06

Hi, sorry if this is a repost. I made this post through the nntp at gmane, but it never appeared in my mail. I have reported some problems with the johnson_all_pairs_shortest_paths and floyd_warshall_all_pairs_shortest_paths algorithms. What is the correct way to report these problems. I made some posts to the list last week, but didn't get any response. Perhaps this should go on the developer mailing list instead? However, the problems I have noticed are: Floyd-Warshall: 1. std::min is used instead of the functor passed to as teh distance_compare parameter at several places 2. The distance map is initialized with 0 instead of zero. Johnson: 3. std::numeric_limits<DT>::max() is used instead of the distance_inf parameter. 4. The distance_combine and distance_compare parameters are not used. The bellman_ford_shortest_paths algorithm is called with std::less and closed_plus. Thanks Peter

2 2