June 2005 - Boost - lists.boost.org

compressed_pair requirements?
by David Abrahams 06 Jun '05

06 Jun '05

Can arguments to compressed_pair be const-qualified? The documentation only lists this restriction: Note that compressed_pair can not be instantiated if either of the template arguments is a union type, unless there is compiler support for boost::is_union, or if boost::is_union is specialised for the union type. I believe I am getting an error from Intel C++ when an argument to compressed_pair is const. The question is whether we need a workaround in compressed_pair.hpp or a change to the html documentation. -- Dave Abrahams Boost Consulting www.boost-consulting.com

6 22

Re: Typeof: Review result
by Tom Brinkman 06 Jun '05

06 Jun '05

Andy Little wrote: > Three positive reviews is not sufficient in my opinion. However, > the precedent has already be set, as other libraries have been approved on > a similar limited number of reviews. >>Obvious questions in response to this... >>How many reviews are sufficient? >> What proportion in favour/against acceptance is acceptable? The judgement of the library's review manager is the final determinent. The criteria that he/she used to accept or reject the submission should be clearly stated in the review managers report after the review period is over. Tom Brinkman

6 5

[lambda] how can I access structure member
by Rafal Dabrowa 06 Jun '05

06 Jun '05

Suppose I have the following structure: struct xy { int x, y; }; and the following vector: vector<xy> v(10); I want to use lambda library for find an item in the table. Let's say, with x member value equal to 10. Something like this doesn't work: pos = find_if(v.begin(), v.end(), _1.x == 10); How the above line should be written ? Rafal

2 1

[assign][range][ptr_container] using-induced problem
by Joaquín Mª López Muñoz 06 Jun '05

06 Jun '05

Martin Wille posted about this a couple of days ago (http://lists.boost.org/boost-testing/2005/05/1216.php) but I'm afraid it could have passed unnoticed. Some tests from Boost.(Assign|Range|PointerContainer) have the following layout #include<...> using namespace std; using namespace boost; ... #include <boost/test/unit_test.hpp> having the using directives before boost/test/unit_test.hpp is AFAICS illegal and does indeed cause problems with GCC 3.4.x and GCC 4.x, see for instance http://tinyurl.com/8payc I cannot test it, but I guess it suffices to move all the includes before any using directive. This will probably clear up dozens of tests, including some toolsets that are currently marked as unusable. Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

4 10

Re: [boost] Re: Re: Boost Array Initialization Technique
by brangdon＠cix.compulink.co.uk 06 Jun '05

06 Jun '05

In-Reply-To: <d7iigr$7tn$1(a)sea.gmane.org> technews(a)kangaroologic.com (Jonathan Turkanis) wrote (abridged): > boost::array is just supposed to give built-in arrays a container > interface. Built-in arrays never have size 0, so I don't see > why boost::arrays should. Surely built-in arrays can have size 0? For example: int n = 0; int *array = new int[n]; In my experience it is important to handle zero edge-cases correctly and uniformly. I have been reading: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1479.html and I don't understand the reasoning there. Personally I'd rather change the language so that: const int n = 0; int array[n]; was acceptable too, making the static case consistent with the dynamic case and both consistent with n>0. Even if this glitch is not fixed (because it requires a language change), I'd rather an array library not perpetuate the problem. For example: array<T,0> a; could allocate a single byte of memory with alignment suitable for T. At worst, sizeof(T) bytes could be allocated, but no T should be constructed. -- Dave Harris, Nottingham, UK.

2 1

Boost Array Initialization Technique
by christopher diggins 06 Jun '05

06 Jun '05

The fact that the Boost array class does not support constructors in favour of the limited and somewhat obscure aggregate initialization syntax has me concerned. IMO it would be much more flexible and powerful to support overloading of the comma operator. The following works on Visual C++ template<typename array_T, unsigned int N> struct array_comma_helper { array_comma_helper(array_T& x) : m(x) { } array_comma_helper(const array_comma_helper& x) : m(x.m) { } array_comma_helper& operator=(typename array_T::value_type x) { m[0] = x; return *this; } mutable array_T& m; }; template<class array_T, unsigned int N, class Scalar_T> array_comma_helper<array_T, N+1> operator,(array_comma_helper<array_T, N> h, const Scalar_T& x) { array_comma_helper<array_T, N+1> ret(h.m); ret.m[N + 1] = x; return ret; } template<class array_T> array_comma_helper<array_T, 0> initialize(array_T& x) { return array_comma_helper<array_T, 0>(x); } This enables us to write: int n = 2; array<int, 3> a; initialize(a) = 1, n, 3; This is much more flexible and it allows us to have constructors in boost::array thus making it a full reversible container. Christopher Diggins http://www.cdiggins.com

15 36

Math constants - updated.
by Paul A Bristow 06 Jun '05

06 Jun '05

I have recently posted to the Boost Sandbox vault an update of my collection of mathematical constants, previously reviewed as a Boost library and ultimately not accepted because of lack of agreement on how to present the constants, especially for User Defined Types, and an outbreak of macrophobia. However the values are still valid and some may find them a useful and convenient source, with even more reassuringly sufficient decimal places to give you a warm feeling ;-) The values are take from Internet sources and then computed with NTL a arbitrary (very high) precision library and presented as 40 decimal digit strings, suitable for all hardware as yet envisioned. I have tried to check as many as possible against two source to try to avoid mistakes, but please tell me of any that you find. The same values are actually presented in header files as macros, floats, doubles, and long doubles, (and also as the functions allowing pi to call a function pi() proposed by Michael Kenniston, even though I am not entirely convinced of their usefulness). So including double_constants.hpp will give lots of values, for example: static const double cubeRootTwo = 1.25992104989487316476721060727822835057; // 2^1/3 If you prefer a macro, the define_constants.h will give you values like #define M_EPOWPI 23.14069263277926900572908636794854738027L /* e^pi */ You can of course also cut and paste invididual lines, if you just want pi. No choice of names will suit everyone - so I have indulged myself. You can change them of course. http://tinyurl.com/7p6es for two zips of headers and documentation as html. Enjoy? Paul PS Some of these values are to be used in the math functions for stats library that I am in danger of getting around to Real Soon Now. Paul A Bristow Prizet Farmhouse, Kendal, Cumbria UK LA8 8AB +44 1539 561830 +44 7714 330204 mailto: pbristow(a)hetp.u-net.com

10 44

Re: [boost] Re: Boost Array Initialization Technique
by brangdon＠cix.compulink.co.uk 06 Jun '05

06 Jun '05

In-Reply-To: <20050601173608.GA77601(a)compsoc.man.ac.uk> cow(a)compsoc.man.ac.uk (Jonathan Wakely) wrote (abridged): > Actually, it's moot because it's been semi-standardised in TR1, not > because you now understand the design goals ;) Really? My impression was that TR1 had not been reviewed in detail. When the hashing library was submitted to boost, I understood it to be the same as TR1 yet we found several problems with it. We did not blindly accept it just because it was in TR1. -- Dave Harris, Nottingham, UK.

4 4

stride iterators and matricies
by christopher diggins 06 Jun '05

06 Jun '05

Well all of this talk of matricies, and what not got me thinking that perhaps we should get back to basics and introduce stride iterators into Boost which properly model the Random Access Iterator concept (unless they are already existant somewhere and I simplty overlooked them :-p ) I would suggest that we introduce a mini-library simply for stride iterators (and k-stride iterators, where the stride factor is a compile-time constant.) Any interest in seeing the following stride iterators submitted to boost as a mini-library? // public domain by Christopher Diggins #ifndef CDIGGINS_STRIDE_ITER_HPP #define CDIGGINS_STRIDE_ITER_HPP #include <iterator> namespace cdiggins { template<class Iter_T> class stride_iter { public: // public typedefs typedef typename std::iterator_traits<Iter_T>::value_type value_type; typedef typename std::iterator_traits<Iter_T>::reference reference; typedef typename std::iterator_traits<Iter_T>::difference_type difference_type; typedef typename std::iterator_traits<Iter_T>::pointer pointer; typedef std::random_access_iterator_tag iterator_category; typedef stride_iter self; // constructors stride_iter() : m(null), step(0) { }; explicit stride_iter(Iter_T x, difference_type n) : m(x), step(n) { } // operators self& operator++() { m += step; return *this; } self operator++(int) { self tmp = *this; m += step; return tmp; } self& operator+=(difference_type x) { m += x * step; return *this; } self& operator--() { m -= step; return *this; } self operator--(int) { self tmp = *this; m -= step; return tmp; } self& operator-=(difference_type x) { m -= x * step; return *this; } reference operator[](difference_type n) { return m[n * step]; } reference operator*() { return *m; } // friend operators friend bool operator==(const self& x, const self& y) { return x.m == y.m; } friend bool operator!=(const self& x, const self& y) { return x.m != y.m; } friend bool operator<(const self& x, const self& y) { return x.m < y.m; } friend difference_type operator-(const self&x, const self& y) { return x.m - y.m; } friend self operator+(const self&x, difference_type y) { return stride_iter(x) += y; } friend self operator+(difference_type x, const self& y) { return stride_iter(y) += x; } private: Iter_T m; difference_type step; }; template<class Iter_T, int Step_N> class kstride_iter { public: // public typedefs typedef typename std::iterator_traits<Iter_T>::value_type value_type; typedef typename std::iterator_traits<Iter_T>::reference reference; typedef typename std::iterator_traits<Iter_T>::difference_type difference_type; typedef typename std::iterator_traits<Iter_T>::pointer pointer; typedef std::random_access_iterator_tag iterator_category; typedef kstride_iter self; // constructors kstride_iter() : m(NULL) { } explicit kstride_iter(Iter_T x) : m(x) { } // operators self& operator++() { m += step(); return *this; } self operator++(int) { self tmp = *this; m += Step_N; return tmp; } self& operator+=(difference_type x) { m += x * Step_N; return *this; } self& operator--() { m -= step(); return *this; } self operator--(int) { self tmp = *this; m -= Step_N; return tmp; } self& operator-=(difference_type x) { m -= x * Step_N; return *this; } reference operator[](difference_type n) { return m[n * Step_N]; } reference operator*() { return *m; } // friend operators friend bool operator==(const self& x, const self& y) { return x.m == y.m; } friend bool operator!=(const self& x, const self& y) { return x.m != y.m; } friend bool operator<(const self& x, const self& y) { return x.m < y.m; } friend difference_type operator-(const self&x, const self& y) { return x.m - y.m; } friend self operator+(const self&x, difference_type y) { return stride_iter(x) += y; } friend self operator+(difference_type x, const self& y) { return stride_iter(y) += x; } private: Iter_T m; }; } #endif Christopher Diggins http://www.cdiggins.com

7 18

[promotion]
by Matt Hurd 06 Jun '05

06 Jun '05

I remember a previous thread lamenting knowledge of boost for both peddling skills and promoting its use within a company. Perhaps another possibility for boost might be an area for advertising positions vacant for boosters. I have a couple of couple of positions now in Sydney in my company and boosters are thin on the ground. I'm toying with the idea of requiring them to contribute to boost as part of their employment, but that may be just my own guilt regarding my lack of contribution. I expect to hire a couple of people that don't know boost exists if previous experience is repeated. I don't know the best way to find boosters and if they are like me they are too busy working to read ads anyway. Such a job area at boost indirectly supports the value proposition of using boost if the skills are seen to have demand. A lot of people learn .NET or Java as this is where the careers seem to be. Then again goodness for goodness sake is perhaps more valuable. I can see both sides so I'm not sure. I also thought that perhaps the large number of hits boost gets could be put to good use with some google ads, banners, or some such, but I'm not sure I'd like to see boost cluttered with advertising. Raises the question of what the monies would be used for anyway. I would also worry it would dilute the nice volunteer collegial ethic that is usually seen around these parts. It that process starts perhaps you inevitably end up with something more like an Apache foundation structure? Dunno. Any thoughts? $0.02 matt matthurd(a)acm.org

2 1