Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:33:29

0001 #ifndef PhysicsTools_Utilities_rootFunction_h
0002 #define PhysicsTools_Utilities_rootFunction_h
0003 #include "PhysicsTools/Utilities/interface/RootFunctionHelper.h"
0004 #include "PhysicsTools/Utilities/interface/Parameter.h"
0005 
0006 namespace root {
0007   template <unsigned int args, typename Tag, typename F>
0008   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f) {
0009     return helper::RootFunctionHelper<F, args, Tag>::fun(f);
0010   }
0011 
0012   template <unsigned int args, typename F>
0013   typename helper::RootFunctionHelper<F, args>::root_function function(F& f) {
0014     return function_t<args, helper::null_t>(f);
0015   }
0016 
0017   template <unsigned int args, typename Tag, typename F>
0018   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f, const funct::Parameter& p0) {
0019     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0020         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0021     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0022     return fun;
0023   }
0024 
0025   template <unsigned int args, typename F>
0026   typename helper::RootFunctionHelper<F, args>::root_function function(F& f, const funct::Parameter& p0) {
0027     return function_t<args, helper::null_t>(f, p0);
0028   }
0029 
0030   template <unsigned int args, typename Tag, typename F>
0031   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0032                                                                               const funct::Parameter& p0,
0033                                                                               const funct::Parameter& p1) {
0034     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0035         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0036     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0037     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0038     return fun;
0039   }
0040 
0041   template <unsigned int args, typename F>
0042   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0043                                                                        const funct::Parameter& p0,
0044                                                                        const funct::Parameter& p1) {
0045     return function<args, helper::null_t>(f, p0, p1);
0046   }
0047 
0048   template <unsigned int args, typename Tag, typename F>
0049   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0050                                                                               const funct::Parameter& p0,
0051                                                                               const funct::Parameter& p1,
0052                                                                               const funct::Parameter& p2) {
0053     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0054         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0055     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0056     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0057     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0058     return fun;
0059   }
0060 
0061   template <unsigned int args, typename F>
0062   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0063                                                                        const funct::Parameter& p0,
0064                                                                        const funct::Parameter& p1,
0065                                                                        const funct::Parameter& p2) {
0066     return function<args, helper::null_t>(f, p0, p1, p2);
0067   }
0068 
0069   template <unsigned int args, typename Tag, typename F>
0070   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0071                                                                               const funct::Parameter& p0,
0072                                                                               const funct::Parameter& p1,
0073                                                                               const funct::Parameter& p2,
0074                                                                               const funct::Parameter& p3) {
0075     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0076         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0077     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0078     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0079     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0080     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0081     return fun;
0082   }
0083 
0084   template <unsigned int args, typename F>
0085   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0086                                                                        const funct::Parameter& p0,
0087                                                                        const funct::Parameter& p1,
0088                                                                        const funct::Parameter& p2,
0089                                                                        const funct::Parameter& p3) {
0090     return function<args, helper::null_t>(f, p0, p1, p2, p3);
0091   }
0092 
0093   template <unsigned int args, typename Tag, typename F>
0094   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0095                                                                               const funct::Parameter& p0,
0096                                                                               const funct::Parameter& p1,
0097                                                                               const funct::Parameter& p2,
0098                                                                               const funct::Parameter& p3,
0099                                                                               const funct::Parameter& p4) {
0100     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0101         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0102     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0103     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0104     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0105     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0106     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0107     return fun;
0108   }
0109 
0110   template <unsigned int args, typename F>
0111   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0112                                                                        const funct::Parameter& p0,
0113                                                                        const funct::Parameter& p1,
0114                                                                        const funct::Parameter& p2,
0115                                                                        const funct::Parameter& p3,
0116                                                                        const funct::Parameter& p4) {
0117     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4);
0118   }
0119 
0120   template <unsigned int args, typename Tag, typename F>
0121   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0122                                                                               const funct::Parameter& p0,
0123                                                                               const funct::Parameter& p1,
0124                                                                               const funct::Parameter& p2,
0125                                                                               const funct::Parameter& p3,
0126                                                                               const funct::Parameter& p4,
0127                                                                               const funct::Parameter& p5) {
0128     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0129         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0130     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0131     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0132     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0133     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0134     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0135     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0136     return fun;
0137   }
0138 
0139   template <unsigned int args, typename F>
0140   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0141                                                                        const funct::Parameter& p0,
0142                                                                        const funct::Parameter& p1,
0143                                                                        const funct::Parameter& p2,
0144                                                                        const funct::Parameter& p3,
0145                                                                        const funct::Parameter& p4,
0146                                                                        const funct::Parameter& p5) {
0147     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5);
0148   }
0149 
0150   template <unsigned int args, typename Tag, typename F>
0151   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0152                                                                               const funct::Parameter& p0,
0153                                                                               const funct::Parameter& p1,
0154                                                                               const funct::Parameter& p2,
0155                                                                               const funct::Parameter& p3,
0156                                                                               const funct::Parameter& p4,
0157                                                                               const funct::Parameter& p5,
0158                                                                               const funct::Parameter& p6) {
0159     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0160         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0161     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0162     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0163     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0164     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0165     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0166     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0167     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0168     return fun;
0169   }
0170 
0171   template <unsigned int args, typename F>
0172   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0173                                                                        const funct::Parameter& p0,
0174                                                                        const funct::Parameter& p1,
0175                                                                        const funct::Parameter& p2,
0176                                                                        const funct::Parameter& p3,
0177                                                                        const funct::Parameter& p4,
0178                                                                        const funct::Parameter& p5,
0179                                                                        const funct::Parameter& p6) {
0180     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6);
0181   }
0182 
0183   template <unsigned int args, typename Tag, typename F>
0184   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0185                                                                               const funct::Parameter& p0,
0186                                                                               const funct::Parameter& p1,
0187                                                                               const funct::Parameter& p2,
0188                                                                               const funct::Parameter& p3,
0189                                                                               const funct::Parameter& p4,
0190                                                                               const funct::Parameter& p5,
0191                                                                               const funct::Parameter& p6,
0192                                                                               const funct::Parameter& p7) {
0193     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0194         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0195     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0196     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0197     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0198     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0199     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0200     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0201     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0202     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0203     return fun;
0204   }
0205 
0206   template <unsigned int args, typename F>
0207   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0208                                                                        const funct::Parameter& p0,
0209                                                                        const funct::Parameter& p1,
0210                                                                        const funct::Parameter& p2,
0211                                                                        const funct::Parameter& p3,
0212                                                                        const funct::Parameter& p4,
0213                                                                        const funct::Parameter& p5,
0214                                                                        const funct::Parameter& p6,
0215                                                                        const funct::Parameter& p7) {
0216     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7);
0217   }
0218 
0219   template <unsigned int args, typename Tag, typename F>
0220   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0221                                                                               const funct::Parameter& p0,
0222                                                                               const funct::Parameter& p1,
0223                                                                               const funct::Parameter& p2,
0224                                                                               const funct::Parameter& p3,
0225                                                                               const funct::Parameter& p4,
0226                                                                               const funct::Parameter& p5,
0227                                                                               const funct::Parameter& p6,
0228                                                                               const funct::Parameter& p7,
0229                                                                               const funct::Parameter& p8) {
0230     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0231         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0232     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0233     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0234     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0235     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0236     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0237     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0238     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0239     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0240     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0241     return fun;
0242   }
0243 
0244   template <unsigned int args, typename F>
0245   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0246                                                                        const funct::Parameter& p0,
0247                                                                        const funct::Parameter& p1,
0248                                                                        const funct::Parameter& p2,
0249                                                                        const funct::Parameter& p3,
0250                                                                        const funct::Parameter& p4,
0251                                                                        const funct::Parameter& p5,
0252                                                                        const funct::Parameter& p6,
0253                                                                        const funct::Parameter& p7,
0254                                                                        const funct::Parameter& p8) {
0255     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8);
0256   }
0257 
0258   template <unsigned int args, typename Tag, typename F>
0259   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0260                                                                               const funct::Parameter& p0,
0261                                                                               const funct::Parameter& p1,
0262                                                                               const funct::Parameter& p2,
0263                                                                               const funct::Parameter& p3,
0264                                                                               const funct::Parameter& p4,
0265                                                                               const funct::Parameter& p5,
0266                                                                               const funct::Parameter& p6,
0267                                                                               const funct::Parameter& p7,
0268                                                                               const funct::Parameter& p8,
0269                                                                               const funct::Parameter& p9) {
0270     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0271         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0272     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0273     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0274     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0275     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0276     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0277     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0278     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0279     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0280     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0281     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0282     return fun;
0283   }
0284 
0285   template <unsigned int args, typename F>
0286   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0287                                                                        const funct::Parameter& p0,
0288                                                                        const funct::Parameter& p1,
0289                                                                        const funct::Parameter& p2,
0290                                                                        const funct::Parameter& p3,
0291                                                                        const funct::Parameter& p4,
0292                                                                        const funct::Parameter& p5,
0293                                                                        const funct::Parameter& p6,
0294                                                                        const funct::Parameter& p7,
0295                                                                        const funct::Parameter& p8,
0296                                                                        const funct::Parameter& p9) {
0297     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
0298   }
0299 
0300   template <unsigned int args, typename Tag, typename F>
0301   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0302                                                                               const funct::Parameter& p0,
0303                                                                               const funct::Parameter& p1,
0304                                                                               const funct::Parameter& p2,
0305                                                                               const funct::Parameter& p3,
0306                                                                               const funct::Parameter& p4,
0307                                                                               const funct::Parameter& p5,
0308                                                                               const funct::Parameter& p6,
0309                                                                               const funct::Parameter& p7,
0310                                                                               const funct::Parameter& p8,
0311                                                                               const funct::Parameter& p9,
0312                                                                               const funct::Parameter& p10) {
0313     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0314         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0315     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0316     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0317     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0318     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0319     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0320     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0321     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0322     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0323     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0324     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0325     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0326     return fun;
0327   }
0328 
0329   template <unsigned int args, typename F>
0330   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0331                                                                        const funct::Parameter& p0,
0332                                                                        const funct::Parameter& p1,
0333                                                                        const funct::Parameter& p2,
0334                                                                        const funct::Parameter& p3,
0335                                                                        const funct::Parameter& p4,
0336                                                                        const funct::Parameter& p5,
0337                                                                        const funct::Parameter& p6,
0338                                                                        const funct::Parameter& p7,
0339                                                                        const funct::Parameter& p8,
0340                                                                        const funct::Parameter& p9,
0341                                                                        const funct::Parameter& p10) {
0342     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
0343   }
0344 
0345   template <unsigned int args, typename Tag, typename F>
0346   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0347                                                                               const funct::Parameter& p0,
0348                                                                               const funct::Parameter& p1,
0349                                                                               const funct::Parameter& p2,
0350                                                                               const funct::Parameter& p3,
0351                                                                               const funct::Parameter& p4,
0352                                                                               const funct::Parameter& p5,
0353                                                                               const funct::Parameter& p6,
0354                                                                               const funct::Parameter& p7,
0355                                                                               const funct::Parameter& p8,
0356                                                                               const funct::Parameter& p9,
0357                                                                               const funct::Parameter& p10,
0358                                                                               const funct::Parameter& p11) {
0359     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0360         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0361     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0362     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0363     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0364     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0365     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0366     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0367     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0368     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0369     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0370     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0371     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0372     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0373     return fun;
0374   }
0375 
0376   template <unsigned int args, typename F>
0377   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0378                                                                        const funct::Parameter& p0,
0379                                                                        const funct::Parameter& p1,
0380                                                                        const funct::Parameter& p2,
0381                                                                        const funct::Parameter& p3,
0382                                                                        const funct::Parameter& p4,
0383                                                                        const funct::Parameter& p5,
0384                                                                        const funct::Parameter& p6,
0385                                                                        const funct::Parameter& p7,
0386                                                                        const funct::Parameter& p8,
0387                                                                        const funct::Parameter& p9,
0388                                                                        const funct::Parameter& p10,
0389                                                                        const funct::Parameter& p11) {
0390     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
0391   }
0392 
0393   template <unsigned int args, typename Tag, typename F>
0394   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0395                                                                               const funct::Parameter& p0,
0396                                                                               const funct::Parameter& p1,
0397                                                                               const funct::Parameter& p2,
0398                                                                               const funct::Parameter& p3,
0399                                                                               const funct::Parameter& p4,
0400                                                                               const funct::Parameter& p5,
0401                                                                               const funct::Parameter& p6,
0402                                                                               const funct::Parameter& p7,
0403                                                                               const funct::Parameter& p8,
0404                                                                               const funct::Parameter& p9,
0405                                                                               const funct::Parameter& p10,
0406                                                                               const funct::Parameter& p11,
0407                                                                               const funct::Parameter& p12) {
0408     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0409         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0410     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0411     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0412     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0413     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0414     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0415     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0416     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0417     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0418     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0419     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0420     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0421     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0422     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0423     return fun;
0424   }
0425 
0426   template <unsigned int args, typename F>
0427   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0428                                                                        const funct::Parameter& p0,
0429                                                                        const funct::Parameter& p1,
0430                                                                        const funct::Parameter& p2,
0431                                                                        const funct::Parameter& p3,
0432                                                                        const funct::Parameter& p4,
0433                                                                        const funct::Parameter& p5,
0434                                                                        const funct::Parameter& p6,
0435                                                                        const funct::Parameter& p7,
0436                                                                        const funct::Parameter& p8,
0437                                                                        const funct::Parameter& p9,
0438                                                                        const funct::Parameter& p10,
0439                                                                        const funct::Parameter& p11,
0440                                                                        const funct::Parameter& p12) {
0441     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
0442   }
0443 
0444   template <unsigned int args, typename Tag, typename F>
0445   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0446                                                                               const funct::Parameter& p0,
0447                                                                               const funct::Parameter& p1,
0448                                                                               const funct::Parameter& p2,
0449                                                                               const funct::Parameter& p3,
0450                                                                               const funct::Parameter& p4,
0451                                                                               const funct::Parameter& p5,
0452                                                                               const funct::Parameter& p6,
0453                                                                               const funct::Parameter& p7,
0454                                                                               const funct::Parameter& p8,
0455                                                                               const funct::Parameter& p9,
0456                                                                               const funct::Parameter& p10,
0457                                                                               const funct::Parameter& p11,
0458                                                                               const funct::Parameter& p12,
0459                                                                               const funct::Parameter& p13) {
0460     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0461         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0462     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0463     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0464     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0465     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0466     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0467     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0468     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0469     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0470     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0471     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0472     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0473     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0474     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0475     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0476     return fun;
0477   }
0478 
0479   template <unsigned int args, typename F>
0480   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0481                                                                        const funct::Parameter& p0,
0482                                                                        const funct::Parameter& p1,
0483                                                                        const funct::Parameter& p2,
0484                                                                        const funct::Parameter& p3,
0485                                                                        const funct::Parameter& p4,
0486                                                                        const funct::Parameter& p5,
0487                                                                        const funct::Parameter& p6,
0488                                                                        const funct::Parameter& p7,
0489                                                                        const funct::Parameter& p8,
0490                                                                        const funct::Parameter& p9,
0491                                                                        const funct::Parameter& p10,
0492                                                                        const funct::Parameter& p11,
0493                                                                        const funct::Parameter& p12,
0494                                                                        const funct::Parameter& p13) {
0495     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
0496   }
0497 
0498   template <unsigned int args, typename Tag, typename F>
0499   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0500                                                                               const funct::Parameter& p0,
0501                                                                               const funct::Parameter& p1,
0502                                                                               const funct::Parameter& p2,
0503                                                                               const funct::Parameter& p3,
0504                                                                               const funct::Parameter& p4,
0505                                                                               const funct::Parameter& p5,
0506                                                                               const funct::Parameter& p6,
0507                                                                               const funct::Parameter& p7,
0508                                                                               const funct::Parameter& p8,
0509                                                                               const funct::Parameter& p9,
0510                                                                               const funct::Parameter& p10,
0511                                                                               const funct::Parameter& p11,
0512                                                                               const funct::Parameter& p12,
0513                                                                               const funct::Parameter& p13,
0514                                                                               const funct::Parameter& p14) {
0515     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0516         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0517     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0518     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0519     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0520     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0521     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0522     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0523     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0524     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0525     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0526     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0527     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0528     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0529     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0530     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0531     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0532     return fun;
0533   }
0534 
0535   template <unsigned int args, typename F>
0536   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0537                                                                        const funct::Parameter& p0,
0538                                                                        const funct::Parameter& p1,
0539                                                                        const funct::Parameter& p2,
0540                                                                        const funct::Parameter& p3,
0541                                                                        const funct::Parameter& p4,
0542                                                                        const funct::Parameter& p5,
0543                                                                        const funct::Parameter& p6,
0544                                                                        const funct::Parameter& p7,
0545                                                                        const funct::Parameter& p8,
0546                                                                        const funct::Parameter& p9,
0547                                                                        const funct::Parameter& p10,
0548                                                                        const funct::Parameter& p11,
0549                                                                        const funct::Parameter& p12,
0550                                                                        const funct::Parameter& p13,
0551                                                                        const funct::Parameter& p14) {
0552     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
0553   }
0554 
0555   template <unsigned int args, typename Tag, typename F>
0556   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0557                                                                               const funct::Parameter& p0,
0558                                                                               const funct::Parameter& p1,
0559                                                                               const funct::Parameter& p2,
0560                                                                               const funct::Parameter& p3,
0561                                                                               const funct::Parameter& p4,
0562                                                                               const funct::Parameter& p5,
0563                                                                               const funct::Parameter& p6,
0564                                                                               const funct::Parameter& p7,
0565                                                                               const funct::Parameter& p8,
0566                                                                               const funct::Parameter& p9,
0567                                                                               const funct::Parameter& p10,
0568                                                                               const funct::Parameter& p11,
0569                                                                               const funct::Parameter& p12,
0570                                                                               const funct::Parameter& p13,
0571                                                                               const funct::Parameter& p14,
0572                                                                               const funct::Parameter& p15) {
0573     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0574         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0575     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0576     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0577     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0578     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0579     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0580     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0581     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0582     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0583     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0584     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0585     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0586     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0587     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0588     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0589     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0590     helper::RootFunctionHelper<F, args, Tag>::addParameter(p15);
0591     return fun;
0592   }
0593 
0594   template <unsigned int args, typename F>
0595   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0596                                                                        const funct::Parameter& p0,
0597                                                                        const funct::Parameter& p1,
0598                                                                        const funct::Parameter& p2,
0599                                                                        const funct::Parameter& p3,
0600                                                                        const funct::Parameter& p4,
0601                                                                        const funct::Parameter& p5,
0602                                                                        const funct::Parameter& p6,
0603                                                                        const funct::Parameter& p7,
0604                                                                        const funct::Parameter& p8,
0605                                                                        const funct::Parameter& p9,
0606                                                                        const funct::Parameter& p10,
0607                                                                        const funct::Parameter& p11,
0608                                                                        const funct::Parameter& p12,
0609                                                                        const funct::Parameter& p13,
0610                                                                        const funct::Parameter& p14,
0611                                                                        const funct::Parameter& p15) {
0612     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
0613   }
0614 
0615   template <unsigned int args, typename Tag, typename F>
0616   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0617                                                                               const funct::Parameter& p0,
0618                                                                               const funct::Parameter& p1,
0619                                                                               const funct::Parameter& p2,
0620                                                                               const funct::Parameter& p3,
0621                                                                               const funct::Parameter& p4,
0622                                                                               const funct::Parameter& p5,
0623                                                                               const funct::Parameter& p6,
0624                                                                               const funct::Parameter& p7,
0625                                                                               const funct::Parameter& p8,
0626                                                                               const funct::Parameter& p9,
0627                                                                               const funct::Parameter& p10,
0628                                                                               const funct::Parameter& p11,
0629                                                                               const funct::Parameter& p12,
0630                                                                               const funct::Parameter& p13,
0631                                                                               const funct::Parameter& p14,
0632                                                                               const funct::Parameter& p15,
0633                                                                               const funct::Parameter& p16) {
0634     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0635         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0636     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0637     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0638     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0639     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0640     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0641     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0642     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0643     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0644     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0645     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0646     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0647     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0648     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0649     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0650     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0651     helper::RootFunctionHelper<F, args, Tag>::addParameter(p15);
0652     helper::RootFunctionHelper<F, args, Tag>::addParameter(p16);
0653     return fun;
0654   }
0655 
0656   template <unsigned int args, typename F>
0657   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0658                                                                        const funct::Parameter& p0,
0659                                                                        const funct::Parameter& p1,
0660                                                                        const funct::Parameter& p2,
0661                                                                        const funct::Parameter& p3,
0662                                                                        const funct::Parameter& p4,
0663                                                                        const funct::Parameter& p5,
0664                                                                        const funct::Parameter& p6,
0665                                                                        const funct::Parameter& p7,
0666                                                                        const funct::Parameter& p8,
0667                                                                        const funct::Parameter& p9,
0668                                                                        const funct::Parameter& p10,
0669                                                                        const funct::Parameter& p11,
0670                                                                        const funct::Parameter& p12,
0671                                                                        const funct::Parameter& p13,
0672                                                                        const funct::Parameter& p14,
0673                                                                        const funct::Parameter& p15,
0674                                                                        const funct::Parameter& p16) {
0675     return function<args, helper::null_t>(f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
0676   }
0677 
0678   template <unsigned int args, typename Tag, typename F>
0679   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0680                                                                               const funct::Parameter& p0,
0681                                                                               const funct::Parameter& p1,
0682                                                                               const funct::Parameter& p2,
0683                                                                               const funct::Parameter& p3,
0684                                                                               const funct::Parameter& p4,
0685                                                                               const funct::Parameter& p5,
0686                                                                               const funct::Parameter& p6,
0687                                                                               const funct::Parameter& p7,
0688                                                                               const funct::Parameter& p8,
0689                                                                               const funct::Parameter& p9,
0690                                                                               const funct::Parameter& p10,
0691                                                                               const funct::Parameter& p11,
0692                                                                               const funct::Parameter& p12,
0693                                                                               const funct::Parameter& p13,
0694                                                                               const funct::Parameter& p14,
0695                                                                               const funct::Parameter& p15,
0696                                                                               const funct::Parameter& p16,
0697                                                                               const funct::Parameter& p17) {
0698     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0699         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0700     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0701     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0702     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0703     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0704     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0705     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0706     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0707     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0708     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0709     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0710     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0711     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0712     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0713     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0714     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0715     helper::RootFunctionHelper<F, args, Tag>::addParameter(p15);
0716     helper::RootFunctionHelper<F, args, Tag>::addParameter(p16);
0717     helper::RootFunctionHelper<F, args, Tag>::addParameter(p17);
0718     return fun;
0719   }
0720 
0721   template <unsigned int args, typename F>
0722   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0723                                                                        const funct::Parameter& p0,
0724                                                                        const funct::Parameter& p1,
0725                                                                        const funct::Parameter& p2,
0726                                                                        const funct::Parameter& p3,
0727                                                                        const funct::Parameter& p4,
0728                                                                        const funct::Parameter& p5,
0729                                                                        const funct::Parameter& p6,
0730                                                                        const funct::Parameter& p7,
0731                                                                        const funct::Parameter& p8,
0732                                                                        const funct::Parameter& p9,
0733                                                                        const funct::Parameter& p10,
0734                                                                        const funct::Parameter& p11,
0735                                                                        const funct::Parameter& p12,
0736                                                                        const funct::Parameter& p13,
0737                                                                        const funct::Parameter& p14,
0738                                                                        const funct::Parameter& p15,
0739                                                                        const funct::Parameter& p16,
0740                                                                        const funct::Parameter& p17) {
0741     return function<args, helper::null_t>(
0742         f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
0743   }
0744 
0745   template <unsigned int args, typename Tag, typename F>
0746   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0747                                                                               const funct::Parameter& p0,
0748                                                                               const funct::Parameter& p1,
0749                                                                               const funct::Parameter& p2,
0750                                                                               const funct::Parameter& p3,
0751                                                                               const funct::Parameter& p4,
0752                                                                               const funct::Parameter& p5,
0753                                                                               const funct::Parameter& p6,
0754                                                                               const funct::Parameter& p7,
0755                                                                               const funct::Parameter& p8,
0756                                                                               const funct::Parameter& p9,
0757                                                                               const funct::Parameter& p10,
0758                                                                               const funct::Parameter& p11,
0759                                                                               const funct::Parameter& p12,
0760                                                                               const funct::Parameter& p13,
0761                                                                               const funct::Parameter& p14,
0762                                                                               const funct::Parameter& p15,
0763                                                                               const funct::Parameter& p16,
0764                                                                               const funct::Parameter& p17,
0765                                                                               const funct::Parameter& p18) {
0766     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0767         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0768     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0769     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0770     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0771     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0772     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0773     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0774     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0775     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0776     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0777     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0778     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0779     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0780     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0781     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0782     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0783     helper::RootFunctionHelper<F, args, Tag>::addParameter(p15);
0784     helper::RootFunctionHelper<F, args, Tag>::addParameter(p16);
0785     helper::RootFunctionHelper<F, args, Tag>::addParameter(p17);
0786     helper::RootFunctionHelper<F, args, Tag>::addParameter(p18);
0787     return fun;
0788   }
0789 
0790   template <unsigned int args, typename F>
0791   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0792                                                                        const funct::Parameter& p0,
0793                                                                        const funct::Parameter& p1,
0794                                                                        const funct::Parameter& p2,
0795                                                                        const funct::Parameter& p3,
0796                                                                        const funct::Parameter& p4,
0797                                                                        const funct::Parameter& p5,
0798                                                                        const funct::Parameter& p6,
0799                                                                        const funct::Parameter& p7,
0800                                                                        const funct::Parameter& p8,
0801                                                                        const funct::Parameter& p9,
0802                                                                        const funct::Parameter& p10,
0803                                                                        const funct::Parameter& p11,
0804                                                                        const funct::Parameter& p12,
0805                                                                        const funct::Parameter& p13,
0806                                                                        const funct::Parameter& p14,
0807                                                                        const funct::Parameter& p15,
0808                                                                        const funct::Parameter& p16,
0809                                                                        const funct::Parameter& p17,
0810                                                                        const funct::Parameter& p18) {
0811     return function<args, helper::null_t>(
0812         f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
0813   }
0814 
0815   template <unsigned int args, typename Tag, typename F>
0816   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(F& f,
0817                                                                               const funct::Parameter& p0,
0818                                                                               const funct::Parameter& p1,
0819                                                                               const funct::Parameter& p2,
0820                                                                               const funct::Parameter& p3,
0821                                                                               const funct::Parameter& p4,
0822                                                                               const funct::Parameter& p5,
0823                                                                               const funct::Parameter& p6,
0824                                                                               const funct::Parameter& p7,
0825                                                                               const funct::Parameter& p8,
0826                                                                               const funct::Parameter& p9,
0827                                                                               const funct::Parameter& p10,
0828                                                                               const funct::Parameter& p11,
0829                                                                               const funct::Parameter& p12,
0830                                                                               const funct::Parameter& p13,
0831                                                                               const funct::Parameter& p14,
0832                                                                               const funct::Parameter& p15,
0833                                                                               const funct::Parameter& p16,
0834                                                                               const funct::Parameter& p17,
0835                                                                               const funct::Parameter& p18,
0836                                                                               const funct::Parameter& p19) {
0837     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0838         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0839     helper::RootFunctionHelper<F, args, Tag>::addParameter(p0);
0840     helper::RootFunctionHelper<F, args, Tag>::addParameter(p1);
0841     helper::RootFunctionHelper<F, args, Tag>::addParameter(p2);
0842     helper::RootFunctionHelper<F, args, Tag>::addParameter(p3);
0843     helper::RootFunctionHelper<F, args, Tag>::addParameter(p4);
0844     helper::RootFunctionHelper<F, args, Tag>::addParameter(p5);
0845     helper::RootFunctionHelper<F, args, Tag>::addParameter(p6);
0846     helper::RootFunctionHelper<F, args, Tag>::addParameter(p7);
0847     helper::RootFunctionHelper<F, args, Tag>::addParameter(p8);
0848     helper::RootFunctionHelper<F, args, Tag>::addParameter(p9);
0849     helper::RootFunctionHelper<F, args, Tag>::addParameter(p10);
0850     helper::RootFunctionHelper<F, args, Tag>::addParameter(p11);
0851     helper::RootFunctionHelper<F, args, Tag>::addParameter(p12);
0852     helper::RootFunctionHelper<F, args, Tag>::addParameter(p13);
0853     helper::RootFunctionHelper<F, args, Tag>::addParameter(p14);
0854     helper::RootFunctionHelper<F, args, Tag>::addParameter(p15);
0855     helper::RootFunctionHelper<F, args, Tag>::addParameter(p16);
0856     helper::RootFunctionHelper<F, args, Tag>::addParameter(p17);
0857     helper::RootFunctionHelper<F, args, Tag>::addParameter(p18);
0858     helper::RootFunctionHelper<F, args, Tag>::addParameter(p19);
0859     return fun;
0860   }
0861 
0862   template <unsigned int args, typename F>
0863   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0864                                                                        const funct::Parameter& p0,
0865                                                                        const funct::Parameter& p1,
0866                                                                        const funct::Parameter& p2,
0867                                                                        const funct::Parameter& p3,
0868                                                                        const funct::Parameter& p4,
0869                                                                        const funct::Parameter& p5,
0870                                                                        const funct::Parameter& p6,
0871                                                                        const funct::Parameter& p7,
0872                                                                        const funct::Parameter& p8,
0873                                                                        const funct::Parameter& p9,
0874                                                                        const funct::Parameter& p10,
0875                                                                        const funct::Parameter& p11,
0876                                                                        const funct::Parameter& p12,
0877                                                                        const funct::Parameter& p13,
0878                                                                        const funct::Parameter& p14,
0879                                                                        const funct::Parameter& p15,
0880                                                                        const funct::Parameter& p16,
0881                                                                        const funct::Parameter& p17,
0882                                                                        const funct::Parameter& p18,
0883                                                                        const funct::Parameter& p19) {
0884     return function<args, helper::null_t>(
0885         f, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
0886   }
0887 
0888   template <unsigned int args, typename Tag, typename F>
0889   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(
0890       F& f, const std::vector<funct::Parameter>& pars) {
0891     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0892         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0893     std::vector<funct::Parameter>::const_iterator i, b = pars.begin(), e = pars.end();
0894     for (i = b; i != e; ++i)
0895       helper::RootFunctionHelper<F, args, Tag>::addParameter(*i);
0896     return fun;
0897   }
0898 
0899   template <unsigned int args, typename F>
0900   typename helper::RootFunctionHelper<F, args>::root_function function(F& f,
0901                                                                        const std::vector<funct::Parameter>& pars) {
0902     return function_t<args, helper::null_t>(f, pars);
0903   }
0904 
0905   template <unsigned int args, typename Tag, typename F>
0906   typename helper::RootFunctionHelper<F, args, Tag>::root_function function_t(
0907       F& f, const std::vector<std::shared_ptr<double> >& pars) {
0908     typename helper::RootFunctionHelper<F, args, Tag>::root_function fun =
0909         helper::RootFunctionHelper<F, args, Tag>::fun(f);
0910     std::vector<std::shared_ptr<double> >::const_iterator i, b = pars.begin(), e = pars.end();
0911     for (i = b; i != e; ++i)
0912       helper::RootFunctionHelper<F, args, Tag>::addParameter(*i);
0913     return fun;
0914   }
0915 
0916   template <unsigned int args, typename F>
0917   typename helper::RootFunctionHelper<F, args>::root_function function(
0918       F& f, const std::vector<std::shared_ptr<double> >& pars) {
0919     return function_t<args, helper::null_t>(f, pars);
0920   }
0921 
0922 }  // namespace root
0923 
0924 #endif