- Boost - lists.boost.org

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

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

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

Submissions
by Detlef Meyer-Eltz 06 Jun '05

06 Jun '05

Hello, I would be glad if you would put my program into your list The name of the Application --------------------------- TextTransformer The name of the company ----------------------- Dr. Detlef Meyer-Eltz A paragraph describing the Application: --------------------------------------- The TextTransformer is a Windows IDE for the generation of top down parsers with included c++ interpreter code for semantic actions. Both can be executed or debugged immediately on single source files or on groups of files. Generated parsers can be exported as c++ code including as well the interpretable code as any arbitrary other code. Tokens are defined as POSIX regular expressions and rules are defined in a similar syntax quasi as regular expressions of regular expressions. The construction of parse trees and their traversal is supported. parts of Boost used ------------------- The TextTransformer is essentially based on the boost regex library, by which the tokens for a parser can be defined. The lexical_cast and the format library are used for the integrated c++ interpreter. For the future also an interpreter version of the string_algo part is planned. The program_options library will be used too to improve the command line version of the texttransformer. URL's to your companies home page --------------------------------- http://www.texttransformer.com Download -------- http://www.texttransformer.com/downloads/setup.exe Thank you very much for your work Detlef Meyer-Eltz -- mailto:Meyer-Eltz@t-online.de url: http://www.texttransformer.de url: http://www.texttransformer.com

1 0

[shmem] New Shmem snapshot in boost vault[retry]
by Ion Gaztañaga 06 Jun '05

06 Jun '05

Hi to all, I sent this yesterday, but I don't see it in the list so I'm resending it again. If previous mail arrives, please forgive me for the duplication: I've just uploaded a new Shmem snapshot to boost vault. Not many changes but it was time to upload the little changes. -> Fixed gcc 3.3.x warnings Caleb pointed out. -> Revised documentation. -> New shared memory container: boost::shmem::deque<> Tested in Visual 7.1/Winxp and gcc 3.4/suse linux 9.3. Remember that Shmem uses unordered associative containers in some tests to make sure that Daniel's hash_map is shared memory friendly. Unordered containers are also in boost vault. Documentation is also online here: http://ice.prohosting.com/newfunk/boost/libs/shmem/index.html Any comment or suggestion is welcome. Regards, Ion

1 0

[program_options] Patch for Tru64/cxx65
by Markus Schöpflin 06 Jun '05

06 Jun '05

Attached patch fixes the last failure on Tru64. (See http://tinyurl.com/dfslr) Ok to commit? Markus Index: parsers_test.cpp =================================================================== RCS file: /cvsroot/boost/boost/libs/program_options/test/parsers_test.cpp,v retrieving revision 1.12 diff -u -w -r1.12 parsers_test.cpp --- parsers_test.cpp 27 Apr 2005 07:02:39 -0000 1.12 +++ parsers_test.cpp 17 May 2005 10:12:16 -0000 @@ -126,7 +126,13 @@ // Regression test: check that '0' as style is interpreted as // 'default_style' vector<option> a4 = - parse_command_line(5, cmdline3_, desc, 0, additional_parser).options; + parse_command_line(5, +#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) + static_cast<char const * const *>(cmdline3_), +#else + cmdline3_, +#endif + desc, 0, additional_parser).options; BOOST_CHECK_EQUAL(a4.size(), 4u); check_value(a4[0], "foo", "4");

3 5

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

06 Jun '05

In-Reply-To: <005501c566b3$1fc76eb0$2b792518@heronnest> cdiggins(a)videotron.ca (christopher diggins) wrote (abridged): > > I strongly disagree. Forcing initialization makes code that is not > > useful for high performance numerical processing. When we declare a > > container of 1000000 elements, we don't want to waste time > > initializing each, unless we want to. > > I think the best solution in this case is to use an alternative > "collection" for numerical processing. Using a class intended as > general purpose array for numerical processing I think would not be a > good idea. I doubt we need a whole class. A special argument might do, to let us choose: boost::array<int,1000> b( boost::uninitialised ); boost::array<int,1000> b( boost::initialised ); The question for me is what the default should be. And in my view, the default should be safe rather than fast. ---- For what it's worth, I think auto variables, std::complex and even std::vector should be the same: initialised by default but with uninitialised available as an option. And since this is now a language change, perhaps "boost::initialised" should be spelt "?" for brevity. int x; // x == 0. int y = ?; // y is uninitialised. int *px = new int; // *px == 0. int *py = new int( ? ) // *py is uninitialised. vector<int> vx( 100 ); // vx.front() is 0. vector<int> vy( 100, ? ); Vectors are complicated in that their elements currently need to be copyable. Either the standard needs to specify when they are copied, so that eg vy is OK as long as the vector is not resized; or else it could make initialisation implementation-defined in the ? case. Then on most platforms, vector<int> would not need initialisation but vector<double> would. User code would not be able to tell the difference. Basically, initialising with ? is telling the implementation that the user will always write to the variable before reading it. The implementation exploits that knowledge as best it can. -- Dave Harris, Nottingham, UK.

4 3

Boost Build Env Checker (was RE: [boost] Re: Customer Friendlier Boost Installation)
by Brian Braatz 06 Jun '05

06 Jun '05

David- Some thoughts below (sorry for taking a bit to come back on this one. I have been contemplating) > -----Original Message----- > From: boost-bounces(a)lists.boost.org [mailto:boost-bounces@lists.boost.org] > On Behalf Of David Abrahams > Sent: Tuesday, May 31, 2005 7:08 AM > To: boost(a)lists.boost.org > Subject: [boost] Re: Customer Friendlier Boost Installation > > "Brian Braatz" <brianb(a)rmtg.com> writes: > > > HAVING said that here is the suggestion, reformed: > > > > Boostenvcheck.exe become s a program which LISTS the dependencies for > > your configuration. > > Can you show an example of what that output might look like? I don't even > have a clear idea of what you mean by "dependencies" or "your > configuration." [Brian Braatz Writes:] I must say, I need to fully absorb how bjam \ boost.build interoperate, until doing so, please understand the details of this idea maybe ill formed. I get it conceptually, but it is still a "black box" in my head. At a high level all I am talking about is the same style of thinking that goes into coding a unit test being applied to a runtime environment. maybe if I provide a different context: (to at least describe the style of thinking I am espousing) lets say I have developed a command line compiler that has a series of dependencies: * INCLUDE var needs to be set to a valid path * We assume some standard files are available here (stdio.h etc) * LIB var needs to be set to a valid path * we assume some standard lib files- or Maybe just assume there is at least ONE lib file there lets say I have shipped my compiler to the masses, and soon I get reports from the users that they have funky errors when trying to compile something. Most of the time, it is USER error. In fact frequently, I may spend hours on the phone with them only to discover they did not configure something correctly or set it up properly. in my frustration over time wasted I decide to write a env checker for my compiler. ill call it clenvcheck.exe. when you run clenvcheck, if I elected to be extreme, I would: 1- validate INCLUDE and LIB vars are set 2- Read the contents of dirs to ensure some or all of the required core files exist 3- display a list of these "dependencies" in my output report i.e. "found stdio.h at c:\brianscompiler\include" 4- check to see if I can find my linker- send the version and location of it to the report 5- display a HIGH Level message denoting whether the "environment passed the test" for my compiler. so armed with this new tool I can now, when talking with folks over the phone, ask them to run the report. when it says "passed"- I can quickly re-direct them back to their code. if they are not convinced, I can have them send me the report and I can look at it and try to determine where the issue is. ADDTIIONAL scenario: Lets say, in my compiler business, I have a scenario where I occasionally release to the users a bug fixed header file. I send out a mail with the new file and explicit instructions on where to put it. After I have released a few bug fixed header files, I find users complaining about weird problems. Turns out, I am now back to spending an dreadful amount of time on the phone only to discover 9 times out of 10 the user did not follow instructions. 1 time out of 10 there actually was a bug in something I released. 10 times out of 10, the customer is frustrated. Even if the customer REALIZES THEY made the mistake, it still leaves them frustrated with ME and my PRODUCT. So I elect to get a bit more extreme in my env checker. I upgrade it so that it adds to the report a hash of all the "things it depends on", i.e. header files, link.exe etc. So now, when the user has a problem, I have them send me the report. I can also make available to them a list of the hashes for the files which I have tested to "work". I spend less time supporting my product, and my customers are happier because I can keep them running much more effectively. I have put a system in place to "Introspect" the users environment. By doing so, I have decreased the amount of time I have to spend introspecting manually. HOW THIS RELATES TO BOOST.BUILD: I need to understand boost.buiid better to give a better suggestion. Hopefully my example might inspire the "Dependancies" to shake out, even if I do not fully understand boost.build yet. I believe this STYLE of thinking can be applied, but I have to get my current boost things done before I can start down this track. As I said before, if the thinking here inspires someone to START something like this all the better . :) IF NOT, I intend on tackling this in the future. (I first have to become a expert in boost.build though :)) I would like to eventually see something that allows someone to SPIT out a report, mail it to the list, and have the people on the list be able to IMMEDIATELY tell the person what could be horked, or why it is not building for them. Cheers, Brian "The Village Idiot" Braatz

2 1