- Boost - lists.boost.org

size limit on files in Sandbox File Vault
by Eric Niebler 28 Mar '05

28 Mar '05

I just tried to upload a new version of xpressive to the Boost Sandbox File Vault, and I received this error: "A file with the name xpressive.zip exceeds maximum allowed size (256 Kb)!" This seems pretty restrictive. The PDF version of xpressive's docs by itself exceeds this limit! I want to include the source code, the regression and perf tests, PDF and HTML documentation, and samples in a single download, but my .zip weighs in at 444 Kb. Can the limit be increased? -- Eric Niebler Boost Consulting www.boost-consulting.com

2 3

Re: [boost] [mpl] float representation
by Cromwell Enage 28 Mar '05

28 Mar '05

--- Andy Little wrote: --- > What is the rationale for the 4 different types > representing rational fractions? Presumably you mean fraction, fraction_c, rational, and rational_c? The fraction_c struct template is simply a metafunction that returns a fraction type, and the rational_c struct template returns a rational type. (Or was it the other way around?) The fraction struct template covers a smaller range of numbers than the rational struct template, but the rational struct template models the concept of a mixed number, which consists of a whole number part and a fraction part, so I figured both the fraction and rational representations were essential. It certainly made implementation simpler. > What is the rationale for making the numerator and > denominator types in fraction_c? In an earlier version, the numerator and denominator were defined by BOOST_STATIC_CONSTANT. Looking through the Integral Constant Guidelines and the MPL source code, I read that certain compilers were likely to complain about the very code I used to have: BOOST_STATIC_CONSTANT before typedef statements, fraction_c<long,7,8>::value inside macros, etc. Not that I have these compilers on hand, but I figured I wasn't making this sub-library just for myself, either, so I searched for a better representation. Lo and behold, Aleksey Gurtovoy created a set of arithmetic metafunction classes that do the dirty work for me. I simply built on top of his work. Thanks for your interest! Cromwell D. Enage __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

2 2

Binary files in CVS
by Peter Dimov 27 Mar '05

27 Mar '05

The following files in the main CVS are binary but do not appear to be marked as such: M libs/program_options/test/ucs2.txt M libs/program_options/test/utf8.txt M libs/ptr_container/doc/cboost.gif The sandbox CVS also contains such files: M boost/ptr_container/ptr_container.tgz M libs/numeric/bindings/doc/c++boost.gif M libs/ptr_container/doc/cboost.gif M libs/sequence_algo/doc/cboost.gif These are corrupted by the Windows CVS clients on every checkout via CR insertion. The easiest way to avoid this is to just not check in binary files in the CVS. -- Peter Dimov http://www.pdimov.com

2 1

Serialization issuses under MS VC++ 7.1 ....
by jason 27 Mar '05

27 Mar '05

I'm all new to C++, let alone Boost, so do excuse me if this is a dumb post, I've only been using C++ for a few weeks now, and come froma web design background. Anyway, I am getting a Error C2780 .\boost_1_32_0\boost\serialization\split_free.hpp(45): error C2780: 'void boost::archive::save(Archive &,const T &)' : expects 2 arguments - 3 provided message when I use STL containers in Boost and the BOOST_SERIALIZATION_SPLIT_MEMBER() macro in my class. I have found when I don't split the serialize method into load / save methods it works fine. However, I need separate load / save methods as some of the members in my class are not serializable (they are SDL resources, and therefore uploading I need to do some other work to restore these members). Here is a chunk of example code that fails... class P { private: int qw; friend class boost::serialization::access; template<class Archive> void serialize(Archive& ar, const unsigned int version) { ar & qw; } public: P() : qw(0) {} P(int Qw) : qw(Qw) {} }; typedef std::list<P*> pList; class Test { pList p; friend class boost::serialization::access; BOOST_SERIALIZATION_SPLIT_MEMBER() template<class Archive> void load(Archive& ar, const unsigned int version) { ar & p; } template<class Archive> void save(Archive& ar, const unsigned int version) const { ar & p; } public: Test() {} }; Using Test t; std::ofstream ofs("frameTest"); boost::archive::text_oarchive oa(ofs); oa << t; ofs.close(); creates this error. To me it seems like this might be a library issue. However could someone point out what I am doing wrong if it is me, and if it is a lib issue, could they hint /suggest some sort of cleanish workaround. I am going to mess about and hack together a workaround by not splitting the serialize method into load/save methods in the class affected for now, however I'm sure other people on this list will be able to suggest better solutions than mine. And yes, I am including the list.hpp file incase anyone thinks I'm not including it. Jason.

3 2

[date_time] missing includes?
by Russell Hind 27 Mar '05

27 Mar '05

I'm just trying date_time on OS X. I've included #include <boost/date_time/posix_time/ptime.hpp> #include <boost/date_time/posix_time/conversion.hpp> This fails to compile with the following error. Including posix_time.hpp rather than ptime.hpp or a gregorian header solves the problem. posix_time/conversion.hpp:33: error: 'to_tm' undeclared in namespace 'boost::gergorian' posix_time/conversion.hpp:45: error: 'date_from_tm' undeclared in namespace 'boost::gregorian' Should the appropriate header be included by posix_time/conversion.hpp? Cheers Russell

2 1

rational variants/alternatives
by Andras Erdei 26 Mar '05

26 Mar '05

i've started to work on the variants that were brought up in a previous discussion about boost::rational<> the current code can be found at www.ccg.hu/pub/src/rat atm it is only for getting the calculations right, so no templates, optimizations, boostification, nice interface etc, and i only tested it with MSVC 7.1 there is also no implementation yet geared towards an unlimited precision representation the variants are: - legacy boost (no rounding, silently gives wrong results) - exceptions are thrown if the result overflows or cannot be represented - rounding - rounding & maintaining an exactness indicator is there anything missing from the list? there is also a simple test-bed, it runs the four basic operations 10000 times on random inputs, and collects some statistics: addition and substraction overflowed 0 times, and the result was exactly representable 44 times; the average error of the legacy code is 475%, and of the rounding code is 0.005% (the exception-throwing variant throws, so there is no error figure for that) multiplication and division overflowed once, and the result was exactly representable 79 times; the average error of the legacy code is 2025%, and of the rounding code is 0.01% it would be nice to get some advice on how the final interface should look like (and of course regarding everything else, including whether there is a point to continue the work): - any ideas for naming the variants? - how should the parameters of rational<> look like? my favourite would be rational<prec,method> where prec is the maximum absolute value allowed for numerators and denominators, and method is one of the variants from above, e.g. rational<10000,round> would be a rounding rational with four decimal digits for the numerator and denominator. of course this would cripple rational<> to be int-based, so maybe specifying the number of bits to be used instead of the maximum value is a sensible approach. (still don't know though how would user-defined types be selected based on this, so maybe the original boost approach is the only workable one.) br, andras ps: i have tried to search the archive for past discussions about rational<> to avoid repeating old stuff, but with very limited success (only the latest posts seem to be accessible) -- any hints?

3 11

boost::is_convertible failure on abstract classes
by Me here 26 Mar '05

26 Mar '05

Hello, The code below does not compile, when, I believe, it should. Compiler says that you can't instantiate abstact class. I'm really surprised - it is trivial use case, but I did not find a problem report. Do I miss something? Regards, Alexander --------------- sample code ------------ #include <boost/static_assert.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits.hpp> struct Data { virtual foo() =0; }; int main(int argc, char* argv[]) { BOOST_STATIC_ASSERT((boost::is_convertible<Data,Data>::value)); return 0; } --------------- sample code ------------ __________________________________ Do you Yahoo!? Yahoo! Small Business - Try our new resources site! http://smallbusiness.yahoo.com/resources/

3 3

test
by Igor Smirnov 25 Mar '05

25 Mar '05

Just a test

1 0

Boost Algorithms Library
by David Abrahams 25 Mar '05

25 Mar '05

As part of my work on the MTL rewrite (http://www.boost-consulting.com/projects/mtl) I have to re-implement the FAST library (http://www.osl.iu.edu/research/mtl/reference/html/#fast) I am re-imagining FAST to use "iterators" whose positions are represented in their types. This is a similar concept to that of a fusion iterator (http://www.boost.org/libs/spirit/fusion/readme.txt) That will allow full loop unrolling for fixed size arrays and their subranges -- the whole point of FAST -- without having to explicitly supply integral constants. Naturally such iterators can't be incremented in-place; traversal will be done with next(i). There will be a function to convert FAST iterators into regular std:: iterators. FAST iterators are different from Fusion iterators in that respect; fusion iterators are heterogeneous in general and so can't have a single value_type. It turns out that OSL (and probably Boost in general) are going to be writing several kinds of algorithm implementations for different kinds of iterators, including segmented algorithms (http://lafstern.org/matt/segmented.pdf) We also have the standard algorithms, Fusion algorithms, and who-knows-what-else so it makes sense to try to supply a common interface that can be used generically, without regard to the kinds of sequences are being operated on. It would also be nice to make the system extensible, so there's at least a chance of providing new algorithm implementations for new kinds of iterator and having things "mostly work." I am planning a sequence/range-based (as opposed to iterator-based) interface, to make sequence adaptation and chaining easier. In case you disagree, I consider that a comparatively uninteresting and orthogonal point, so I'd prefer to save any arguments on that for later. As far as I can tell, the only reasonable way to unify these libraries extensibly is to provide a central algorithm dispatcher that is called with qualification, e.g.: boost::algorithm::transform(input_sequence, op, output_sequence) The easiest way to do dispatching is to use ADL based on tags associated with the sequences or their iterators, something like: // algorithm.hpp namespace boost { namespace algorithm { template <class I, class Op, class O> something transform(I input_sequence, Op op, O output_sequence) { return transform_impl( input_sequence , algorithm::get_tag(input_sequence) , op , output_sequence , algorithm::get_tag(output_sequence)); } }} // fast.hpp namespace boost { namespace algorithm { namespace fast { struct fast_tag {}; template <class I, class Op, class O, class T> something transform_impl( I input_sequence, fast_tag, Op op, O output_sequence, T) { // ... whatever ... } }}} I believe ambiguities will be the greatest obstacle to extensibility, especially because many algorithms (e.g. the 2-sequence version of transform) can operate on utterly different sequences. It's possible to add another transform overload without the tag arguments in fast:: so that users can explicitly invoke fast::transform in case algorithm::transform is ambiguous, but that won't help when transform is being invoked from within some library whose code the user doesn't control. Another problem is that determining the type of "something" for the outer transform can be complicated. That's related to the use of ADL dispatching because we might have to determine how the ADL works out just to understand where to find the return type calculation. Yes, typeof would solve that problem. The ambiguity problem can be resolved by going to a specialization-based dispatch. It allows us to silently choose one of many equal implementations in case of ambiguity, which can be neccessary if you want to prevent ambiguities from arising in libraries over which the user has no control. The user can also add specializations to resolve the ambiguity, though that leads to the risk of clashing specializations. That approach adds a great deal of machinery for something we haven't even seen to be a problem in practice yet. For an example, see the end of the message. I am inclined to go with ADL-based dispatching, at least for now. Whether results should be lazy (as in Fusion) or greedy, as in standard algorithms, or whether both variants should be provided somehow, are interesting questions. The answers change the usage pattern, i.e.: copy(transform(s1,op), output) or output = transform(s1,op) // if output supports it vs. transform(s1,op,output) Your thoughts on these topics would be much appreciated. ---------- // Specialization-based dispatch example // algorithm.hpp namespace boost { namespace algorithm { // algorithm identifier struct transform_tag {}; // Map some implementation identifier into a transform implementation. template <class IO> struct transform_impl; // A metafunction to trace refinement relations among sequence // concept tags. E.G., // refines<random_access_sequence_tag>::type // yields bidirectional_sequence_tag. We can work out a protocol // for "multiple refinement," if neccessary. template <class Tag> struct refines; // implementation -- produce an implementation for an algorithm // and set of sequence types and category tags // // ID must be a function type of the form: // algorithm-identifier ( Seq1, tag1, ... SeqN, tagN ) // template <class ID> struct implementation { typedef mpl::false_ is_specialized; typedef mpl::int_<0> score; }; // If there's no closer specialization, then try again with the // "base" sequence category. template <class Algorithm, class S1,class Tag> struct implementation<Algorithm(S1,Tag)> : implementation<Algorithm(S1,typename refines<Tag>::type)> { typedef typename mpl::next< typename implementation< Algorithm(S1,typename refines<Tag>::type) >::score >::type score; }; // If there's no closer specialization, then try again with the // "base" sequence categories. template <class Algorithm, class S1, class Tag1, class S2, class Tag2> struct implementation<Algorithm(S1,Tag1,S2,Tag2)> : best_scoring< // definition left as exercise ;-) mpl::vector2< implementation< Algorithm(S1,typename refines<Tag1>::type,S2,Tag2) > , implementation< Algorithm(S1,Tag1,S2,typename refines<Tag2>::type) > > >::type {}; // ... // impl -- dispatch an algorithm and sequence types to a given // implementation // // ID must be a function type of the form: // algorithm-identifier ( Seq1, ... SeqN ) // template <class ID> struct impl; template <class Algorithm, class S1> struct impl<Algorithm(S1)> : implementation<Algorithm(S1, typename sequence_tag<S1>::type)> {}; template <class Algorithm, class S1, class S2> struct impl<Algorithm(S1)> : implementation< Algorithm( S1, typename sequence_tag<S1>::type , S2, typename sequence_tag<S2>::type )> {}; // ... // Dispatching wrapper for transform implementations template <class I, class Op, class O> impl<transform_tag(I,O)>::result_type transform(I input_sequence, Op op, O output_sequence) { impl<transform_tag(I,O)> ::execute(input_sequence, op, output_sequence); } }} // fast.hpp namespace boost { namespace algorithm { namespace fast { struct tag {}; // identify FAST sequences }}} namespace boost { namespace algorithm { // A transform algorithm implementation for FAST input sequences template <class I, class O, class OTag> struct implementation< transform_tag(I,fast::tag,O,OTag) > { // ... } }} -- Dave Abrahams Boost Consulting www.boost-consulting.com

2 4

[serialization] typo's in is_abstract.hpp
by Eelis van der Weegen 25 Mar '05

25 Mar '05

Line 25 in boost/serialization/is_abstract.hpp uses _GNUC__ and __GNU_MINOR. Both are incorrectly spelled; the correct names are __GNUC__ and __GNUC_MINOR__. Regards, Eelis

2 1