- Boost-users - lists.boost.org

Enumerating paths and euler paths in a graph
by Yaron Kretchmer 03 Mar '10

03 Mar '10

Hi There. I'm a boost newbie, so my apologies if this has been discussed before: I need to 1) Enumerate all paths of a certain length in a given graph. 2) Find all Euler paths in a given eulerian graph. Any idea on how to do that with boost? Thanks Yaron

1 0

boost::input_filter and negative char
by eial＠cs.bgu.ac.il 03 Mar '10

03 Mar '10

hello. I've seem to found a strange behavior within boost::input_filter, I'm writing data to a file using bzip2 compressor, in this issue all goes well, now when I read the data (I post process the data after the de/compression) because some of the chars are negative, then cases where there are two sequential -1 causes the filter to end processing even if the file isn't at eof. what can be done to prevent it? should this even happen? here are the test results: http://www.4shared.com/file/233035989/8bde1629/testresults.html

2 2

[traits/function_types/generic] Can F be called with {a0, ..., aN}?
by Rutger ter Borg 03 Mar '10

03 Mar '10

Hello, I have been trying to achieve assignment to a variant of functions, typedef boost::variant< boost::function< int >, boost::function< int, int > > variant_type; which is nice until you try to assign an ambiguous callable object to it, especially if the callable object has templates or similar. This has lead to my question: is there a way to know (without the "no matching function call" compiler error if {a0,...,aN} in F(a0,a1,...,aN) are permissible arguments to callable object/function F? I thought I had a nice solution by overriding boost::result_of< F(a0,a1..,aN)>::type in such way that it doesn't give compile errors if a type doesn't exist, but mpl::na (in conjunction with a has_result_of<T> meta-function). Then, writing functors like struct some_func { template< typename Sig > struct result { // no type defined here, so result_of<>::type is not defined } template< ... > struct result< enable_if arguments are acceptable > { typedef ... type; } R operator()( ... ) {} }; gives you the ability to answer the question for those particular functors. However, some widely used stuff like boost::bind always has a result_type, so this trick was a dead end. So, in short, does anyone know of a generic trick to know if F can be called with a set parameters {a0,...,aN} (without the compile error)? Thanks, Cheers, Rutger

2 6

[boost-users] [test] Boost.Test Mock
by Andrey Torba 03 Mar '10

03 Mar '10

Hi All, Whare can i find information about Boost.Test Mock? -- Regards, Andrey

2 4

[serialization] class versioning changes in boost 1.42
by David Raulo 02 Mar '10

02 Mar '10

Hi, It seems that the serialization library shipped with boost 1.42 changed the way class versions are handled. The version_type which used to be an unsigned int is now an uint_least16_t, although I found no mention of that in the release notes. The problem is that we are using a date-based versioning scheme for our classes (for example a developer making a change in some class on 2010-02-22 would increment the class version to 20100222). This scheme worked great for a couple of years, and helped us fix our backward compatibility bugs after the fact. Unfortunately, these big version numbers do not fit in 16-bit integers. As a consequence, the version string output in xml archives with the latest boost-serialization for this example would be 46206 instead of 20100222, breaking our reloading code. May I ask why this change was made? Would it be possible to revert it for the next boost release? If not, anyone has suggestions how we could fix our code while maintaining backward compatibility ? (we have old archives in the wild generated with various releases of our code, which we need to be able to reload). Thanks for any help, David.

7 33

[proto] defining function call operators on expressions
by Manjunath Kudlur 02 Mar '10

02 Mar '10

I am trying to define operator()(...) for my expressions. I want to be able to form expression of the form Program_(a,b) and call Program_(a, b)(10,20). Here, 'a' and 'b' are terminals and I have a mechanism shown in the code below that somehow gets the type suitable for the parameter position. Suppose 'a' is terminal<Var<int> >, I want the first parameter position in Program_(a,b) (pos1, pos2) to be of the type 'int'. typename boost::result_of<call_param_type<M>(const Expr &)>::type gives me that type for the Mth argument in the expression of the form Program_(a1,a2,...). Now, I am trying to use this to define operator()(...) in my program_expr class. That doesn't seem to work. However, if I define a separate function callfunc, that takes the expression and the arguments, that seems to work. In the following code, enabling the if 0'ed out code results in compilation errors. How do I go about defining operator()(...) in my program_expr class with the above property? Thanks, Manjunath #include <boost/proto/proto.hpp> #include <boost/proto/proto_typeof.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/assert.hpp> #include <iostream> #include <sstream> #include <string> namespace proto=boost::proto; namespace mpl=boost::mpl; unsigned int ids; template<typename VT> struct Var { unsigned int id; Var() { id = ++ids; } }; typedef proto::terminal<Var<int> >::type int32_; typedef proto::terminal<Var<float> >::type float_; struct program_ {}; template<class E> struct program_expr; struct program_domain : proto::domain<proto::pod_generator<program_expr> > { }; struct _var_type : proto::callable { template<typename Sig> struct result; template<typename This, typename T> struct result<This(const Var<T> &)> { typedef T type; }; }; struct var_type : proto::or_< proto::when<proto::terminal<Var<proto::_> >, _var_type(proto::_value)> > {}; template<int N> struct call_param_type : proto::or_< proto::when< proto::function< proto::terminal<program_>, proto::vararg<proto::terminal<Var<proto::_> > > >, var_type(proto::_child_c<N+1>)> > {}; template <typename Expr> struct program_expr { BOOST_PROTO_BASIC_EXTENDS(Expr, program_expr<Expr>, program_domain); BOOST_PROTO_EXTENDS_SUBSCRIPT(); typedef void result_type; #if 0 result_type operator()(typename boost::result_of<call_param_type<0>(const Expr &)>::type x) { std::cout << "program with one arg\n"; } result_type operator()(typename boost::result_of<call_param_type<0>(const Expr &)>::type x, typename boost::result_of<call_param_type<1>(const Expr &)>::type y) { std::cout << "program with two args\n"; } #endif }; template<typename Expr> void callfunc(const Expr &e, typename boost::result_of<call_param_type<0>(const Expr &)>::type x) { std::cout << "program with one arg\n"; } template<typename Expr> void callfunc(const Expr &e, typename boost::result_of<call_param_type<0>(const Expr &)>::type x, typename boost::result_of<call_param_type<1>(const Expr &)>::type y) { std::cout << "program with two args\n"; } template<typename A0> typename proto::result_of::make_expr<proto::tag::function , program_domain , program_ , A0 const &>::type const Program_(A0 const &a0) { return proto::make_expr<proto::tag::function, program_domain>( program_(), boost::ref(a0)); } template<typename A0, typename A1> typename proto::result_of::make_expr<proto::tag::function , program_domain , program_ , A0 const & , A1 const &>::type const Program_(A0 const &a0, A1 const &a1) { return proto::make_expr<proto::tag::function, program_domain>( program_(), boost::ref(a0), boost::ref(a1)); } int main() { int32_ a,b,c; callfunc(Program_(a, b), 10, 20); #if 0 Program_(a, b)(10, 20); #endif }

3 8

problem with memcpy to shared memory
by Cuneyt Taskiran 02 Mar '10

02 Mar '10

Hi, I want to create a buffer in shared memory and have modified the example code provided in Boost.Interprocess to get the following class: template<typename ItemType> class SharedMemoryBufferMock { private: ItemType* m_data; // array of ItemType items ItemType* m_read_ptr; // points to next buffer location to be read from ItemType* m_write_ptr; // points to next buffer location to be written to std::string m_segmentName; // unique name for the memory segment that holds the buffer object std::string m_objectName; // unique name for the buffer object unsigned long m_nItems; unsigned long m_capacity; public: SharedMemoryBufferMock( unsigned long maxItemCount ); virtual ~SharedMemoryBufferMock(); unsigned long capacity() { return m_capacity; } unsigned long size() { return m_nItems; } bool isFull() { return m_nItems == m_capacity; } bool isEmpty() { return m_nItems == 0; } ItemType* read(); void write( ItemType* item_ptr); }; /* * Implementation of the templated methods. */ template<typename ItemType>SharedMemoryBufferMock<ItemType>::SharedMemoryBufferMock( unsigned long maxItemCount ) { if( maxItemCount == 0 ) { std::cerr << "Buffer cannot be created with a capacity of zero!" << std::endl; exit(1); } // Create unique name for memory segment using PID of current process. std::stringstream pid_str; pid_str << "BufferMemorySegment_" << getpid(); m_segmentName = pid_str.str(); pid_str.str(""); pid_str << "BufferMemoryObject_" << getpid(); m_objectName = pid_str.str(); boost::interprocess::shared_memory_object::remove(m_segmentName.c_str()); m_capacity = maxItemCount; // Create a new segment with given name and size boost::interprocess::managed_shared_memory segment( boost::interprocess::create_only, m_segmentName.c_str(), //memSize 65536 ); // Create the buffer data object with specified item capacity. m_data = segment.construct<ItemType> ( m_objectName.c_str() ) // name of the object [maxItemCount] // number of items (ItemType()); // ctor for elements // Initialize read and write locations. m_write_ptr = m_read_ptr = m_data; } template<typename ItemType> void SharedMemoryBufferMock<ItemType>::write( ItemType* item_ptr ) { if( isFull() ) { std::cerr << "Cannot write to buffer, it's full. Read one or more elements first!" << std::endl; exit(1); } std::memcpy( m_write_ptr, item_ptr, sizeof(ItemType) ); m_write_ptr++; m_nItems++; } When I test the code using the following: SharedMemoryBufferMock<int> sharedBuf(100); for( int i = 0; i < 10; i++ ) { cout << "writing " << i << endl; sharedBuf.write( &i ); } I get a segmentation fault at the memcpy step. I've been at this for a couple of hours now and cannot see what I'm doing wrong. Any comments would be greatly appreciated. Thanks, C

1 1

boost/accumulators - chi-square test, calculation of p-values
by Christine SINOQUET 02 Mar '10

02 Mar '10

Hello everybody, I have to implement the Pearson chi-square test in C++. I do not succeed in finding the appropriate instructions to use boost for this purpose. I am not even sure of the library file I ought to use. Many thanks in advance for any help. Best regards, Christine Sinoquet // convention: // df: degrees of freedom // css_observed: observed chi-squared score #include <boost/accumulators/statistics/stats.hpp> void chi_squared_test(){ typedef accumulator_set<double, stats<tag::p_square_cumulative_distribution> > accumulator_t; accumulator_t acc(tag::p_square_cumulative_distribution::<???tag in connexion with df (degrees of freedom)???>); double p = acc(<access to cumulative function for css_observed>) ... } _________________________________________________________________________________ Note 1: As far as I can see, the code below found on Internet does not correspond at all to my boost library : // df: degrees of freedom // css_observed: observed chi-squared score boost::math::chi_squared mydist(df); // usage of the cdf accessor function (cumulative distribution function) to compute the p-value // corresponding to the observed chi-squared score with df degrees of freedom. // p(css <= css_observed) = F(css_observed) float p = boost::math::cdf(mydist,css_observed); // p-value = 1 - p is the probability of observing a chi-squared score at least as extreme as css_observed, // if one assumes the null hypothesis holds. ___________________________________________________________________________________ Note 2: Below is the content of .../boost/include/boost/accumulators/statistics : count.hpp covariance.hpp density.hpp directory error_of.hpp error_of_mean.hpp extended_p_square.hpp extended_p_square_quantile.hpp kurtosis.hpp max.hpp mean.hpp median.hpp min.hpp moment.hpp parameters peaks_over_threshold.hpp pot_quantile.hpp pot_tail_mean.hpp p_square_cumulative_distribution.hpp p_square_quantile.hpp skewness.hpp stats.hpp sum.hpp tail.hpp tail_mean.hpp tail_quantile.hpp tail_variate.hpp tail_variate_means.hpp times2_iterator.hpp variance.hpp variates weighted_covariance.hpp weighted_density.hpp weighted_extended_p_square.hpp weighted_kurtosis.hpp weighted_mean.hpp weighted_median.hpp weighted_moment.hpp weighted_peaks_over_threshold.hpp weighted_p_square_cumulative_distribution.hpp weighted_p_square_quantile.hpp weighted_skewness.hpp weighted_sum.hpp weighted_tail_mean.hpp weighted_tail_quantile.hpp weighted_tail_variate_means.hpp weighted_variance.hpp with_error.hpp

1 0

Re: [Boost-users] [Fusion] transform / transform_view / binary sequence iteration
by Hicham Mouline 02 Mar '10

02 Mar '10

-----Original Message----- From: "Thomas Taylor" [thomas.taylor(a)univie.ac.at] Date: 02/03/2010 11:49 AM To: boost-users(a)lists.boost.org Subject: Re: [Boost-users] [Fusion] transform / transform_view / binary sequence iteration Hi! Started out with tuple but soon moved to fusion as it suits my needs much better, so thanks for fusion! My problem is the following: list<A,B,C> seq2(1,2,3); list<W<A>,W<B>,W<C> > seq1; struct fa { typedef unsigned int result_type; template <typename S1, typename S2> result_type operator()(const S1& s1, const S2& s2) const { return s1(s2); // this calls W<A>(A), W<B>(B), W<C>(C) } }; struct fb { typedef std::vector<unsigned int> result_type; template <typename T> result_type operator()(const result_type& a, const T& t) const { result_type a2(a); a2.push_back(t); return a2; } }; accumulate( transform(seq1,seq2,fa()),fb() ); /* The above yields an error: no matching function for call to ‘accumulate(boost::fusion::transform_view<const boost::fusion::list<W<double>, W<double>, W<double>, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_>, const boost::fusion::list<double, double, double, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_>, database::histogram::fb>) */ How can I use a transform_view (the result of transform(S1,S2,F)) as input for accumulate? Thank you, Thomas _______________________________________________ In my basic experience, this has been a matter of constness. Checkout fusion docs and make sure you follow exactly the function signatures. Oh! you need an initial state for accumulate() rds,

2 1

[Fusion] transform / transform_view / binary sequence iteration
by Thomas Taylor 02 Mar '10

02 Mar '10

Hi! Started out with tuple but soon moved to fusion as it suits my needs much better, so thanks for fusion! My problem is the following: list<A,B,C> seq2(1,2,3); list<W<A>,W<B>,W<C> > seq1; struct fa { typedef unsigned int result_type; template <typename S1, typename S2> result_type operator()(const S1& s1, const S2& s2) const { return s1(s2); // this calls W<A>(A), W<B>(B), W<C>(C) } }; struct fb { typedef std::vector<unsigned int> result_type; template <typename T> result_type operator()(const result_type& a, const T& t) const { result_type a2(a); a2.push_back(t); return a2; } }; accumulate( transform(seq1,seq2,fa()),fb() ); /* The above yields an error: no matching function for call to ‘accumulate(boost::fusion::transform_view<const boost::fusion::list<W<double>, W<double>, W<double>, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_>, const boost::fusion::list<double, double, double, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_>, database::histogram::fb>) */ How can I use a transform_view (the result of transform(S1,S2,F)) as input for accumulate? Thank you, Thomas

1 0