Hi, besides the more complex possibility to use boost::tuple and generate recursive Tree<X> List : derived from Tree<X-1> ...: derived from Tree<0> specialization, why not using a boost::array instead? Here an example: template<class T, size N> struct Tree { typedef boost::array<T, N> parameters_types; T sum(parameters_type const& p) { return std::accumulate(p.begin(), p.end(), 0); } }; This is type safe and fast ;) and your users can initialize boost array with an initializer list like: parameters_type x = { 1, 2, 3, 4, 5... }; Regards, Ovanes On Jan 28, 2008 8:26 PM, Hicham Mouline <hicham@mouline.org> wrote:

After some though, here is more precisely what I'd like to have... I apologize that it is quite different from the initial problem:

template<int n> class Tree { static double sum(); // };

If the user instantiates tree<2>, he should get:

template<> class Tree<2> { static double sum(double d1, double d2); };

template<> class Tree<3> { static double sum(double d1, double d2, double d3); }; etc etc...

so that in user code, for e.g.:

double d= Tree<4>::sum(d1, d2, d3, d4);

should compile.

Is it possible for me to just define the template Tree for the n-case without the 2- and 3- specializations?

Rds,

-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Steven Watanabe Sent: 28 January 2008 16:42 To: boost-users@lists.boost.org Subject: Re: [Boost-users] Template instantiation function arguments and Boost.Preprocessor

AMDG

Hicham Mouline wrote:

...

hi,

i have a template function, the arguments of which i wish to have depend on a non-type int template argument:

template<int n> double f<n>( double arg0, double arg1, ..., double argn ) // ... is not the variadic notation for var number of args { // for(int i=0; i<n; i++) // code return sum; }

int main() { return x = f<3>( 1.0, 2.0, 3.0 ); }

BOOST_PP_REPEAT can't seem to do the job as the template argument n needs to be known at the preprocessing stage, which happens before the template instantiation stage ( this is part of compilation)

I don't understand why you want n to be passed explicitly. Can't it be deduced from the number of arguments (warning untested):

#define SUM_IMPL(z, n, data) + arg ## n #define F_DEF(z, n, data) double f(BOOST_PP_ENUM_PARAMS_Z(z, n, double arg)) { return(0.0 BOOST_PP_REPEAT_ ## z(n, SUM_IMPL, ~)); }

BOOST_PP_REPEAT(MAX_ARITY, F_DEF, ~)

In Christ, Steven Watanabe

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

-- No virus found in this incoming message. Checked by AVG Free Edition. Version: 7.5.516 / Virus Database: 269.19.14/1247 - Release Date: 1/28/2008 10:59 AM

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

Sorry, but your test was wrong. Try to pass the array to sum as const reference. In your case you always copy the array!!! It should not be faster. On Jan 28, 2008 9:55 PM, Hicham Mouline <hicham@mouline.org> wrote:

Hi, thanks for your answers,

Because I had tested just with :

1. static double sum(double d1, double d2, double d3) { return d1+d2+d3; }

vs

2. static double sum(double d[3]) { return d[0]+d[1]+d[2];

}

with calls to sum() in a tight loop.

I suspect boost::array is equivalent to 2.

was some 40% faster than 2 with advanced intel optimization.

Could you elaborate on the recursive generation?

Rds,

template<class T, size N> struct Tree { typedef boost::array<T, N> parameters_types;

};

*From:* boost-users-bounces@lists.boost.org [mailto: boost-users-bounces@lists.boost.org] *On Behalf Of *Ovanes Markarian *Sent:* 28 January 2008 21:27

*To:* boost-users@lists.boost.org *Subject:* Re: [Boost-users] Template instantiation function arguments and Boost.Preprocessor

Hi,

besides the more complex possibility to use boost::tuple and generate recursive Tree<X> List : derived from Tree<X-1> ...: derived from Tree<0> specialization, why not using a boost::array instead?

Here an example:

template<class T, size N> struct Tree { typedef boost::array<T, N> parameters_types;

T sum(parameters_type const& p) { return std::accumulate(p.begin(), p.end(), 0); }

};

This is type safe and fast ;) and your users can initialize boost array with an initializer list like:

parameters_type x = { 1, 2, 3, 4, 5... };

Regards, Ovanes

On Jan 28, 2008 8:26 PM, Hicham Mouline <hicham@mouline.org> wrote:

After some though, here is more precisely what I'd like to have... I apologize that it is quite different from the initial problem:

template<int n> class Tree { static double sum(); // };

If the user instantiates tree<2>, he should get:

template<> class Tree<2> { static double sum(double d1, double d2); };

template<> class Tree<3> { static double sum(double d1, double d2, double d3); }; etc etc...

so that in user code, for e.g.:

double d= Tree<4>::sum(d1, d2, d3, d4);

should compile.

Is it possible for me to just define the template Tree for the n-case without the 2- and 3- specializations?

Rds,

-----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Steven Watanabe Sent: 28 January 2008 16:42 To: boost-users@lists.boost.org Subject: Re: [Boost-users] Template instantiation function arguments and Boost.Preprocessor

AMDG

Hicham Mouline wrote:

...

hi,

i have a template function, the arguments of which i wish to have depend on a non-type int template argument:

template<int n> double f<n>( double arg0, double arg1, ..., double argn ) // ... is not the variadic notation for var number of args { // for(int i=0; i<n; i++) // code return sum; }

int main() { return x = f<3>( 1.0, 2.0, 3.0 ); }

BOOST_PP_REPEAT can't seem to do the job as the template argument n needs to be known at the preprocessing stage, which happens before the template instantiation stage ( this is part of compilation)

I don't understand why you want n to be passed explicitly. Can't it be deduced from the number of arguments (warning untested):

#define SUM_IMPL(z, n, data) + arg ## n #define F_DEF(z, n, data) double f(BOOST_PP_ENUM_PARAMS_Z(z, n, double arg)) { return(0.0 BOOST_PP_REPEAT_ ## z(n, SUM_IMPL, ~)); }

BOOST_PP_REPEAT(MAX_ARITY, F_DEF, ~)

In Christ, Steven Watanabe

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

-- No virus found in this incoming message. Checked by AVG Free Edition. Version: 7.5.516 / Virus Database: 269.19.14/1247 - Release Date: 1/28/2008 10:59 AM

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

AMDG Hicham Mouline wrote:

After some though, here is more precisely what I'd like to have... I apologize that it is quite different from the initial problem:

template<int n> class Tree { static double sum(); // };

If the user instantiates tree<2>, he should get:

template<> class Tree<2> { static double sum(double d1, double d2); };

template<> class Tree<3> { static double sum(double d1, double d2, double d3); }; etc etc...

so that in user code, for e.g.:

double d= Tree<4>::sum(d1, d2, d3, d4);

should compile.

Is it possible for me to just define the template Tree for the n-case without the 2- and 3- specializations?

Ah. You still need the preprocessor, but you can rearrange the definitions slightly. (untested) template<int N> struct TreeSumImpl; #define TREE_SUM_DEF(z, n, data)\ template<>\ struct TreeSumImpl<n> {\ static double sum(BOOST_PP_ENUM_PARAMS_Z(z, n, double arg)) { ... }\ }; BOOST_PP_REPEAT(20, TREE_SUM_DEF, ~) template<int N> struct Tree : TreeSumImpl<N> { // other code }; In Christ, Steven Watanabe

sorry, I have overseen it somehow... Probably too late already... That's true, that array argument to a function is a pointer. Sorry. I have tested the code with gcc under MacOS X, the function with arguments as 3 doubles was NOT necesserely faster as the boost::array param. It might be not worse implementing the macro based approach... Here is my test app compiled with O3 optimization flags. (Below are the timing on a Dual Core 2.4 processor machine with 4 gb ram) //============================================================================ // Name : CppTest.cpp // Author : // Version : // Copyright : Your copyright notice // Description : Hello World in C++, Ansi-style //============================================================================ #include <iostream> #include <numeric> #include <boost/array.hpp> #include <boost/progress.hpp> using namespace std; typedef boost::array<double, 3> array_type; array_type::value_type sum_arr_copy(array_type a) { return (a[0]+=a[1])+=a[2]; } array_type::value_type sum_carr(array_type const& a) { return a[0]+a[1]+a[2]; } array_type::value_type sum_carr_temp_result(array_type const& a) { double result=a[0]; return (result+=a[1])+=a[2]; } array_type::value_type sum_carr_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0); } array_type::value_type sum_arr_copy_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0); } double sum_doubles_copy(double d1, double d2, double d3) { return d1+d2+d3; } double sum_doubles_copy_optimized(double d1, double d2, double d3) { return (d1+=d2)+=d3; } double sum_doubles_copy_temp_result(double d1, double d2, double d3) { double result=d1; return (result+=d2)+=d3; } double sum_doubles_ref_temp_result(double const& d1, double const& d2, double const d3) { double result=d1; return (result+=d2)+=d3; } /// sorry for macro code. I was too lazy to copy paste it... #define ARR_P() a #define DBL_P() d1,d2,d3 #define DO_TEST(function, param_seq) \ { \ cout << "--------------------------\n" \ << #function"\n"; \ double result=0; \ { \ boost::progress_timer t; \ for(unsigned long i=0; i<times; ++i) \ result+=function(param_seq()); \ } \ cout << "result: " << result << "\n"; \ } int main() { const unsigned long times=~0; array_type a = {1.0, 2.3, 3.33}; double d1 = 1.0, d2 = 2.3, d3 = 3.33; DO_TEST(sum_arr_copy, ARR_P); DO_TEST(sum_carr, ARR_P); DO_TEST(sum_arr_copy_accumulate, ARR_P); DO_TEST(sum_carr_temp_result, ARR_P); DO_TEST(sum_carr_accumulate, ARR_P); DO_TEST(sum_doubles_copy, DBL_P); DO_TEST(sum_doubles_copy_optimized, DBL_P); DO_TEST(sum_doubles_copy_temp_result, DBL_P); DO_TEST(sum_doubles_ref_temp_result, DBL_P); cout << "tests done" << endl; return 0; } Please take a look, that accumulate produced wrong result. Resulting timings after running each test 4294967295 times: -------------------------- sum_arr_copy 65.19 s result: 2.84756e+10 -------------------------- sum_carr 14.99 s result: 2.84756e+10 -------------------------- sum_arr_copy_accumulate 59.97 s result: 2.57698e+10 -------------------------- sum_carr_temp_result 14.97 s result: 2.84756e+10 -------------------------- sum_carr_accumulate 59.84 s result: 2.57698e+10 -------------------------- sum_doubles_copy 15.00 s result: 2.84756e+10 -------------------------- sum_doubles_copy_optimized 14.98 s result: 2.84756e+10 -------------------------- sum_doubles_copy_temp_result 14.92 s result: 2.84756e+10 -------------------------- sum_doubles_ref_temp_result 14.93 s result: 2.84756e+10 tests done I hope that helps and will not require you to develop some solution, which might not be worth the effort. Good Luck! Ovanes On Jan 28, 2008 10:39 PM, Steven Watanabe <watanabesj@gmail.com> wrote:

AMDG

Hicham Mouline wrote:

...

After some though, here is more precisely what I'd like to have... I apologize that it is quite different from the initial problem:

template<int n> class Tree { static double sum(); // };

If the user instantiates tree<2>, he should get:

template<> class Tree<2> { static double sum(double d1, double d2); };

template<> class Tree<3> { static double sum(double d1, double d2, double d3); }; etc etc...

so that in user code, for e.g.:

double d= Tree<4>::sum(d1, d2, d3, d4);

should compile.

Is it possible for me to just define the template Tree for the n-case without the 2- and 3- specializations?

Ah. You still need the preprocessor, but you can rearrange the definitions slightly. (untested)

template<int N> struct TreeSumImpl;

#define TREE_SUM_DEF(z, n, data)\ template<>\ struct TreeSumImpl<n> {\ static double sum(BOOST_PP_ENUM_PARAMS_Z(z, n, double arg)) { ... }\ };

BOOST_PP_REPEAT(20, TREE_SUM_DEF, ~)

template<int N> struct Tree : TreeSumImpl<N> { // other code };

In Christ, Steven Watanabe

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

Seven, thanks a lot for pointing it out. That was a classical error!! :( Anyway I re-ran the test, with corrected accumulate calls: corrected calls: array_type::value_type sum_carr_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0.0); } array_type::value_type sum_arr_copy_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0.0); } Results (which would be expected from std lib ;) Running each test 4294967295 of times: -------------------------- sum_arr_copy 64.79 s result: 2.84756e+10 -------------------------- sum_carr 14.91 s result: 2.84756e+10 -------------------------- sum_arr_copy_accumulate 14.91 s result: 2.84756e+10 -------------------------- sum_carr_temp_result 14.91 s result: 2.84756e+10 -------------------------- sum_carr_accumulate 14.91 s result: 2.84756e+10 -------------------------- sum_doubles_copy 15.00 s result: 2.84756e+10 -------------------------- sum_doubles_copy_optimized 14.96 s result: 2.84756e+10 -------------------------- sum_doubles_copy_temp_result 14.92 s result: 2.84756e+10 -------------------------- sum_doubles_ref_temp_result 14.97 s result: 2.84756e+10 tests done Regards, Ovanes On Jan 29, 2008 5:42 AM, Steven Watanabe <watanabesj@gmail.com> wrote:

AMDG

Ovanes Markarian wrote:

...

array_type::value_type sum_carr_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0); }

array_type::value_type sum_arr_copy_accumulate(array_type const& a) { return std::accumulate(a.begin(), a.end(), 0); }

...

Please take a look, that accumulate produced wrong result.

Of course. The results are being collected in an int...

In Christ, Steven Watanabe

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

Hello, Is there any implementation of a priority queue, that is not thread-safe (lock-free), where the caller has the responsibility to check for thread safety? Regards,