Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-01-18 09:50:22 

0001         ///////////////////////////////////////////////////////////////////////////////
0002         /// \file expr.hpp
0003         /// Contains definition of expr\<\> class template.
0004         //
0005         //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006         //  Software License, Version 1.0. (See accompanying file
0007         //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008         
0009     
0010     
0011     
0012     
0013     
0014     
0015     
0016     
0017     
0018     
0019     
0020     
0021     
0022     
0023     
0024     
0025     
0026     
0027     
0028     
0029     
0030     
0031     
0032     
0033     
0034     
0035     
0036     template<typename Tag, typename Arg0>
0037     struct expr<Tag, term<Arg0>, 0>
0038     {
0039         typedef Tag proto_tag;
0040         static const long proto_arity_c = 0;
0041         typedef mpl::long_<0 > proto_arity;
0042         typedef expr proto_base_expr;
0043         typedef term<Arg0> proto_args;
0044         typedef basic_expr<Tag, proto_args, 0 > proto_grammar;
0045         typedef default_domain proto_domain;
0046         typedef default_generator proto_generator;
0047         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0048         typedef expr proto_derived_expr;
0049         typedef void proto_is_expr_; 
0050         typedef Arg0 proto_child0; proto_child0 child0;
0051         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0052         
0053         
0054         BOOST_FORCEINLINE
0055         expr const &proto_base() const
0056         {
0057             return *this;
0058         }
0059         
0060         
0061         BOOST_FORCEINLINE
0062         expr &proto_base()
0063         {
0064             return *this;
0065         }
0066         
0067         
0068         
0069         template<typename A0>
0070         BOOST_FORCEINLINE
0071         static expr const make(A0 &a0)
0072         {
0073             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
0074         }
0075         
0076         
0077         template<typename A0>
0078         BOOST_FORCEINLINE
0079         static expr const make(A0 const &a0)
0080         {
0081             return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
0082         }
0083         
0084         
0085         typedef detail::not_a_valid_type address_of_hack_type_;
0086         
0087         
0088         
0089         
0090         BOOST_FORCEINLINE
0091         proto::expr<
0092             proto::tag::assign
0093           , list2<expr &, expr const &>
0094           , 2
0095         > const
0096         operator =(expr const &a)
0097         {
0098             proto::expr<
0099                 proto::tag::assign
0100               , list2<expr &, expr const &>
0101               , 2
0102             > that = {*this, a};
0103             return that;
0104         }
0105         
0106         
0107         
0108         
0109         template<typename A>
0110         BOOST_FORCEINLINE
0111         proto::expr<
0112             proto::tag::assign
0113           , list2<expr const &, typename result_of::as_child<A>::type>
0114           , 2
0115         > const
0116         operator =(A &a) const
0117         {
0118             proto::expr<
0119                 proto::tag::assign
0120               , list2<expr const &, typename result_of::as_child<A>::type>
0121               , 2
0122             > that = {*this, proto::as_child(a)};
0123             return that;
0124         }
0125         
0126         
0127         template<typename A>
0128         BOOST_FORCEINLINE
0129         proto::expr<
0130             proto::tag::assign
0131           , list2<expr const &, typename result_of::as_child<A const>::type>
0132           , 2
0133         > const
0134         operator =(A const &a) const
0135         {
0136             proto::expr<
0137                 proto::tag::assign
0138               , list2<expr const &, typename result_of::as_child<A const>::type>
0139               , 2
0140             > that = {*this, proto::as_child(a)};
0141             return that;
0142         }
0143         
0144         
0145         template<typename A>
0146         BOOST_FORCEINLINE
0147         proto::expr<
0148             proto::tag::assign
0149           , list2<expr &, typename result_of::as_child<A>::type>
0150           , 2
0151         > const
0152         operator =(A &a)
0153         {
0154             proto::expr<
0155                 proto::tag::assign
0156               , list2<expr &, typename result_of::as_child<A>::type>
0157               , 2
0158             > that = {*this, proto::as_child(a)};
0159             return that;
0160         }
0161         
0162         
0163         template<typename A>
0164         BOOST_FORCEINLINE
0165         proto::expr<
0166             proto::tag::assign
0167           , list2<expr &, typename result_of::as_child<A const>::type>
0168           , 2
0169         > const
0170         operator =(A const &a)
0171         {
0172             proto::expr<
0173                 proto::tag::assign
0174               , list2<expr &, typename result_of::as_child<A const>::type>
0175               , 2
0176             > that = {*this, proto::as_child(a)};
0177             return that;
0178         }
0179         
0180         
0181         
0182         
0183         template<typename A>
0184         BOOST_FORCEINLINE
0185         proto::expr<
0186             proto::tag::subscript
0187           , list2<expr const &, typename result_of::as_child<A>::type>
0188           , 2
0189         > const
0190         operator [](A &a) const
0191         {
0192             proto::expr<
0193                 proto::tag::subscript
0194               , list2<expr const &, typename result_of::as_child<A>::type>
0195               , 2
0196             > that = {*this, proto::as_child(a)};
0197             return that;
0198         }
0199         
0200         
0201         template<typename A>
0202         BOOST_FORCEINLINE
0203         proto::expr<
0204             proto::tag::subscript
0205           , list2<expr const &, typename result_of::as_child<A const>::type>
0206           , 2
0207         > const
0208         operator [](A const &a) const
0209         {
0210             proto::expr<
0211                 proto::tag::subscript
0212               , list2<expr const &, typename result_of::as_child<A const>::type>
0213               , 2
0214             > that = {*this, proto::as_child(a)};
0215             return that;
0216         }
0217         
0218         
0219         template<typename A>
0220         BOOST_FORCEINLINE
0221         proto::expr<
0222             proto::tag::subscript
0223           , list2<expr &, typename result_of::as_child<A>::type>
0224           , 2
0225         > const
0226         operator [](A &a)
0227         {
0228             proto::expr<
0229                 proto::tag::subscript
0230               , list2<expr &, typename result_of::as_child<A>::type>
0231               , 2
0232             > that = {*this, proto::as_child(a)};
0233             return that;
0234         }
0235         
0236         
0237         template<typename A>
0238         BOOST_FORCEINLINE
0239         proto::expr<
0240             proto::tag::subscript
0241           , list2<expr &, typename result_of::as_child<A const>::type>
0242           , 2
0243         > const
0244         operator [](A const &a)
0245         {
0246             proto::expr<
0247                 proto::tag::subscript
0248               , list2<expr &, typename result_of::as_child<A const>::type>
0249               , 2
0250             > that = {*this, proto::as_child(a)};
0251             return that;
0252         }
0253         
0254         
0255         template<typename Sig>
0256         struct result
0257         {
0258             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0259         };
0260         
0261         
0262         
0263         BOOST_FORCEINLINE
0264         proto::expr<proto::tag::function, list1<expr const &>, 1> const
0265         operator ()() const
0266         {
0267             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
0268             return that;
0269         }
0270         
0271         
0272         BOOST_FORCEINLINE
0273         proto::expr<proto::tag::function, list1<expr &>, 1> const
0274         operator ()()
0275         {
0276             proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
0277             return that;
0278         }
0279         
0280         
0281         template<typename A0>
0282         BOOST_FORCEINLINE
0283         typename result_of::funop1<
0284             expr const
0285           , default_domain , const A0
0286         >::type const
0287         operator ()(A0 const &a0) const
0288         {
0289             return result_of::funop1<
0290                 expr const
0291               , default_domain , const A0
0292             >::call(*this , a0);
0293         }
0294         
0295         
0296         template<typename A0>
0297         BOOST_FORCEINLINE
0298         typename result_of::funop1<
0299             expr
0300           , default_domain , const A0
0301         >::type const
0302         operator ()(A0 const &a0)
0303         {
0304             return result_of::funop1<
0305                 expr
0306               , default_domain , const A0
0307             >::call(*this , a0);
0308         }
0309         
0310         
0311         template<typename A0 , typename A1>
0312         BOOST_FORCEINLINE
0313         typename result_of::funop2<
0314             expr const
0315           , default_domain , const A0 , const A1
0316         >::type const
0317         operator ()(A0 const &a0 , A1 const &a1) const
0318         {
0319             return result_of::funop2<
0320                 expr const
0321               , default_domain , const A0 , const A1
0322             >::call(*this , a0 , a1);
0323         }
0324         
0325         
0326         template<typename A0 , typename A1>
0327         BOOST_FORCEINLINE
0328         typename result_of::funop2<
0329             expr
0330           , default_domain , const A0 , const A1
0331         >::type const
0332         operator ()(A0 const &a0 , A1 const &a1)
0333         {
0334             return result_of::funop2<
0335                 expr
0336               , default_domain , const A0 , const A1
0337             >::call(*this , a0 , a1);
0338         }
0339         
0340         
0341         template<typename A0 , typename A1 , typename A2>
0342         BOOST_FORCEINLINE
0343         typename result_of::funop3<
0344             expr const
0345           , default_domain , const A0 , const A1 , const A2
0346         >::type const
0347         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
0348         {
0349             return result_of::funop3<
0350                 expr const
0351               , default_domain , const A0 , const A1 , const A2
0352             >::call(*this , a0 , a1 , a2);
0353         }
0354         
0355         
0356         template<typename A0 , typename A1 , typename A2>
0357         BOOST_FORCEINLINE
0358         typename result_of::funop3<
0359             expr
0360           , default_domain , const A0 , const A1 , const A2
0361         >::type const
0362         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2)
0363         {
0364             return result_of::funop3<
0365                 expr
0366               , default_domain , const A0 , const A1 , const A2
0367             >::call(*this , a0 , a1 , a2);
0368         }
0369         
0370         
0371         template<typename A0 , typename A1 , typename A2 , typename A3>
0372         BOOST_FORCEINLINE
0373         typename result_of::funop4<
0374             expr const
0375           , default_domain , const A0 , const A1 , const A2 , const A3
0376         >::type const
0377         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
0378         {
0379             return result_of::funop4<
0380                 expr const
0381               , default_domain , const A0 , const A1 , const A2 , const A3
0382             >::call(*this , a0 , a1 , a2 , a3);
0383         }
0384         
0385         
0386         template<typename A0 , typename A1 , typename A2 , typename A3>
0387         BOOST_FORCEINLINE
0388         typename result_of::funop4<
0389             expr
0390           , default_domain , const A0 , const A1 , const A2 , const A3
0391         >::type const
0392         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
0393         {
0394             return result_of::funop4<
0395                 expr
0396               , default_domain , const A0 , const A1 , const A2 , const A3
0397             >::call(*this , a0 , a1 , a2 , a3);
0398         }
0399         
0400         
0401         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0402         BOOST_FORCEINLINE
0403         typename result_of::funop5<
0404             expr const
0405           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0406         >::type const
0407         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
0408         {
0409             return result_of::funop5<
0410                 expr const
0411               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0412             >::call(*this , a0 , a1 , a2 , a3 , a4);
0413         }
0414         
0415         
0416         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0417         BOOST_FORCEINLINE
0418         typename result_of::funop5<
0419             expr
0420           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0421         >::type const
0422         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
0423         {
0424             return result_of::funop5<
0425                 expr
0426               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0427             >::call(*this , a0 , a1 , a2 , a3 , a4);
0428         }
0429         
0430         
0431         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0432         BOOST_FORCEINLINE
0433         typename result_of::funop6<
0434             expr const
0435           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0436         >::type const
0437         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
0438         {
0439             return result_of::funop6<
0440                 expr const
0441               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0442             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
0443         }
0444         
0445         
0446         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0447         BOOST_FORCEINLINE
0448         typename result_of::funop6<
0449             expr
0450           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0451         >::type const
0452         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
0453         {
0454             return result_of::funop6<
0455                 expr
0456               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0457             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
0458         }
0459         
0460         
0461         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0462         BOOST_FORCEINLINE
0463         typename result_of::funop7<
0464             expr const
0465           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0466         >::type const
0467         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
0468         {
0469             return result_of::funop7<
0470                 expr const
0471               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0472             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
0473         }
0474         
0475         
0476         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0477         BOOST_FORCEINLINE
0478         typename result_of::funop7<
0479             expr
0480           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0481         >::type const
0482         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
0483         {
0484             return result_of::funop7<
0485                 expr
0486               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0487             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
0488         }
0489         
0490         
0491         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0492         BOOST_FORCEINLINE
0493         typename result_of::funop8<
0494             expr const
0495           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0496         >::type const
0497         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
0498         {
0499             return result_of::funop8<
0500                 expr const
0501               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0502             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0503         }
0504         
0505         
0506         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0507         BOOST_FORCEINLINE
0508         typename result_of::funop8<
0509             expr
0510           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0511         >::type const
0512         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
0513         {
0514             return result_of::funop8<
0515                 expr
0516               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0517             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0518         }
0519         
0520         
0521         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0522         BOOST_FORCEINLINE
0523         typename result_of::funop9<
0524             expr const
0525           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0526         >::type const
0527         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
0528         {
0529             return result_of::funop9<
0530                 expr const
0531               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0532             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0533         }
0534         
0535         
0536         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0537         BOOST_FORCEINLINE
0538         typename result_of::funop9<
0539             expr
0540           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0541         >::type const
0542         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
0543         {
0544             return result_of::funop9<
0545                 expr
0546               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0547             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0548         }
0549     };
0550     
0551     
0552     
0553     
0554     
0555     
0556     
0557     
0558     
0559     
0560     
0561     
0562     
0563     
0564     
0565     
0566     
0567     
0568     
0569     
0570     
0571     
0572     
0573     
0574     
0575     
0576     
0577     template<typename Tag , typename Arg0>
0578     struct expr<Tag, list1<Arg0>, 1 >
0579     {
0580         typedef Tag proto_tag;
0581         static const long proto_arity_c = 1;
0582         typedef mpl::long_<1 > proto_arity;
0583         typedef expr proto_base_expr;
0584         typedef list1<Arg0> proto_args;
0585         typedef basic_expr<Tag, proto_args, 1 > proto_grammar;
0586         typedef default_domain proto_domain;
0587         typedef default_generator proto_generator;
0588         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0589         typedef expr proto_derived_expr;
0590         typedef void proto_is_expr_; 
0591         typedef Arg0 proto_child0; proto_child0 child0;
0592         typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0593         
0594         
0595         BOOST_FORCEINLINE
0596         expr const &proto_base() const
0597         {
0598             return *this;
0599         }
0600         
0601         
0602         BOOST_FORCEINLINE
0603         expr &proto_base()
0604         {
0605             return *this;
0606         }
0607         
0608         
0609         
0610         template<typename A0>
0611         BOOST_FORCEINLINE
0612         static expr const make(A0 const &a0)
0613         {
0614             expr that = {a0};
0615             return that;
0616         }
0617         
0618         
0619         
0620         typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
0621         
0622         
0623         
0624         
0625         
0626         
0627         
0628         BOOST_FORCEINLINE
0629         operator address_of_hack_type_() const
0630         {
0631             return boost::addressof(this->child0);
0632         }
0633         
0634         
0635         
0636         
0637         BOOST_FORCEINLINE
0638         proto::expr<
0639             proto::tag::assign
0640           , list2<expr &, expr const &>
0641           , 2
0642         > const
0643         operator =(expr const &a)
0644         {
0645             proto::expr<
0646                 proto::tag::assign
0647               , list2<expr &, expr const &>
0648               , 2
0649             > that = {*this, a};
0650             return that;
0651         }
0652         
0653         
0654         
0655         
0656         template<typename A>
0657         BOOST_FORCEINLINE
0658         proto::expr<
0659             proto::tag::assign
0660           , list2<expr const &, typename result_of::as_child<A>::type>
0661           , 2
0662         > const
0663         operator =(A &a) const
0664         {
0665             proto::expr<
0666                 proto::tag::assign
0667               , list2<expr const &, typename result_of::as_child<A>::type>
0668               , 2
0669             > that = {*this, proto::as_child(a)};
0670             return that;
0671         }
0672         
0673         
0674         template<typename A>
0675         BOOST_FORCEINLINE
0676         proto::expr<
0677             proto::tag::assign
0678           , list2<expr const &, typename result_of::as_child<A const>::type>
0679           , 2
0680         > const
0681         operator =(A const &a) const
0682         {
0683             proto::expr<
0684                 proto::tag::assign
0685               , list2<expr const &, typename result_of::as_child<A const>::type>
0686               , 2
0687             > that = {*this, proto::as_child(a)};
0688             return that;
0689         }
0690         
0691         
0692         
0693         
0694         template<typename A>
0695         BOOST_FORCEINLINE
0696         proto::expr<
0697             proto::tag::subscript
0698           , list2<expr const &, typename result_of::as_child<A>::type>
0699           , 2
0700         > const
0701         operator [](A &a) const
0702         {
0703             proto::expr<
0704                 proto::tag::subscript
0705               , list2<expr const &, typename result_of::as_child<A>::type>
0706               , 2
0707             > that = {*this, proto::as_child(a)};
0708             return that;
0709         }
0710         
0711         
0712         template<typename A>
0713         BOOST_FORCEINLINE
0714         proto::expr<
0715             proto::tag::subscript
0716           , list2<expr const &, typename result_of::as_child<A const>::type>
0717           , 2
0718         > const
0719         operator [](A const &a) const
0720         {
0721             proto::expr<
0722                 proto::tag::subscript
0723               , list2<expr const &, typename result_of::as_child<A const>::type>
0724               , 2
0725             > that = {*this, proto::as_child(a)};
0726             return that;
0727         }
0728         
0729         
0730         template<typename Sig>
0731         struct result
0732         {
0733             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
0734         };
0735         
0736         
0737         
0738         BOOST_FORCEINLINE
0739         proto::expr<proto::tag::function, list1<expr const &>, 1> const
0740         operator ()() const
0741         {
0742             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
0743             return that;
0744         }
0745         
0746         
0747         template<typename A0>
0748         BOOST_FORCEINLINE
0749         typename result_of::funop1<
0750             expr const
0751           , default_domain , const A0
0752         >::type const
0753         operator ()(A0 const &a0) const
0754         {
0755             return result_of::funop1<
0756                 expr const
0757               , default_domain , const A0
0758             >::call(*this , a0);
0759         }
0760         
0761         
0762         template<typename A0 , typename A1>
0763         BOOST_FORCEINLINE
0764         typename result_of::funop2<
0765             expr const
0766           , default_domain , const A0 , const A1
0767         >::type const
0768         operator ()(A0 const &a0 , A1 const &a1) const
0769         {
0770             return result_of::funop2<
0771                 expr const
0772               , default_domain , const A0 , const A1
0773             >::call(*this , a0 , a1);
0774         }
0775         
0776         
0777         template<typename A0 , typename A1 , typename A2>
0778         BOOST_FORCEINLINE
0779         typename result_of::funop3<
0780             expr const
0781           , default_domain , const A0 , const A1 , const A2
0782         >::type const
0783         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
0784         {
0785             return result_of::funop3<
0786                 expr const
0787               , default_domain , const A0 , const A1 , const A2
0788             >::call(*this , a0 , a1 , a2);
0789         }
0790         
0791         
0792         template<typename A0 , typename A1 , typename A2 , typename A3>
0793         BOOST_FORCEINLINE
0794         typename result_of::funop4<
0795             expr const
0796           , default_domain , const A0 , const A1 , const A2 , const A3
0797         >::type const
0798         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
0799         {
0800             return result_of::funop4<
0801                 expr const
0802               , default_domain , const A0 , const A1 , const A2 , const A3
0803             >::call(*this , a0 , a1 , a2 , a3);
0804         }
0805         
0806         
0807         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0808         BOOST_FORCEINLINE
0809         typename result_of::funop5<
0810             expr const
0811           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0812         >::type const
0813         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
0814         {
0815             return result_of::funop5<
0816                 expr const
0817               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
0818             >::call(*this , a0 , a1 , a2 , a3 , a4);
0819         }
0820         
0821         
0822         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0823         BOOST_FORCEINLINE
0824         typename result_of::funop6<
0825             expr const
0826           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0827         >::type const
0828         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
0829         {
0830             return result_of::funop6<
0831                 expr const
0832               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
0833             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
0834         }
0835         
0836         
0837         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0838         BOOST_FORCEINLINE
0839         typename result_of::funop7<
0840             expr const
0841           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0842         >::type const
0843         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
0844         {
0845             return result_of::funop7<
0846                 expr const
0847               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
0848             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
0849         }
0850         
0851         
0852         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0853         BOOST_FORCEINLINE
0854         typename result_of::funop8<
0855             expr const
0856           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0857         >::type const
0858         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
0859         {
0860             return result_of::funop8<
0861                 expr const
0862               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
0863             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
0864         }
0865         
0866         
0867         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0868         BOOST_FORCEINLINE
0869         typename result_of::funop9<
0870             expr const
0871           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0872         >::type const
0873         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
0874         {
0875             return result_of::funop9<
0876                 expr const
0877               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
0878             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
0879         }
0880     };
0881     
0882     
0883     
0884     
0885     
0886     
0887     
0888     
0889     
0890     
0891     
0892     
0893     
0894     
0895     
0896     
0897     
0898     
0899     
0900     
0901     
0902     
0903     
0904     
0905     
0906     
0907     
0908     template<typename Tag , typename Arg0 , typename Arg1>
0909     struct expr<Tag, list2<Arg0 , Arg1>, 2 >
0910     {
0911         typedef Tag proto_tag;
0912         static const long proto_arity_c = 2;
0913         typedef mpl::long_<2 > proto_arity;
0914         typedef expr proto_base_expr;
0915         typedef list2<Arg0 , Arg1> proto_args;
0916         typedef basic_expr<Tag, proto_args, 2 > proto_grammar;
0917         typedef default_domain proto_domain;
0918         typedef default_generator proto_generator;
0919         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
0920         typedef expr proto_derived_expr;
0921         typedef void proto_is_expr_; 
0922         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
0923         typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
0924         
0925         
0926         BOOST_FORCEINLINE
0927         expr const &proto_base() const
0928         {
0929             return *this;
0930         }
0931         
0932         
0933         BOOST_FORCEINLINE
0934         expr &proto_base()
0935         {
0936             return *this;
0937         }
0938         
0939         
0940         
0941         template<typename A0 , typename A1>
0942         BOOST_FORCEINLINE
0943         static expr const make(A0 const &a0 , A1 const &a1)
0944         {
0945             expr that = {a0 , a1};
0946             return that;
0947         }
0948         
0949         
0950         typedef detail::not_a_valid_type address_of_hack_type_;
0951         
0952         
0953         
0954         
0955         BOOST_FORCEINLINE
0956         proto::expr<
0957             proto::tag::assign
0958           , list2<expr &, expr const &>
0959           , 2
0960         > const
0961         operator =(expr const &a)
0962         {
0963             proto::expr<
0964                 proto::tag::assign
0965               , list2<expr &, expr const &>
0966               , 2
0967             > that = {*this, a};
0968             return that;
0969         }
0970         
0971         
0972         
0973         
0974         template<typename A>
0975         BOOST_FORCEINLINE
0976         proto::expr<
0977             proto::tag::assign
0978           , list2<expr const &, typename result_of::as_child<A>::type>
0979           , 2
0980         > const
0981         operator =(A &a) const
0982         {
0983             proto::expr<
0984                 proto::tag::assign
0985               , list2<expr const &, typename result_of::as_child<A>::type>
0986               , 2
0987             > that = {*this, proto::as_child(a)};
0988             return that;
0989         }
0990         
0991         
0992         template<typename A>
0993         BOOST_FORCEINLINE
0994         proto::expr<
0995             proto::tag::assign
0996           , list2<expr const &, typename result_of::as_child<A const>::type>
0997           , 2
0998         > const
0999         operator =(A const &a) const
1000         {
1001             proto::expr<
1002                 proto::tag::assign
1003               , list2<expr const &, typename result_of::as_child<A const>::type>
1004               , 2
1005             > that = {*this, proto::as_child(a)};
1006             return that;
1007         }
1008         
1009         
1010         
1011         
1012         template<typename A>
1013         BOOST_FORCEINLINE
1014         proto::expr<
1015             proto::tag::subscript
1016           , list2<expr const &, typename result_of::as_child<A>::type>
1017           , 2
1018         > const
1019         operator [](A &a) const
1020         {
1021             proto::expr<
1022                 proto::tag::subscript
1023               , list2<expr const &, typename result_of::as_child<A>::type>
1024               , 2
1025             > that = {*this, proto::as_child(a)};
1026             return that;
1027         }
1028         
1029         
1030         template<typename A>
1031         BOOST_FORCEINLINE
1032         proto::expr<
1033             proto::tag::subscript
1034           , list2<expr const &, typename result_of::as_child<A const>::type>
1035           , 2
1036         > const
1037         operator [](A const &a) const
1038         {
1039             proto::expr<
1040                 proto::tag::subscript
1041               , list2<expr const &, typename result_of::as_child<A const>::type>
1042               , 2
1043             > that = {*this, proto::as_child(a)};
1044             return that;
1045         }
1046         
1047         
1048         template<typename Sig>
1049         struct result
1050         {
1051             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1052         };
1053         
1054         
1055         
1056         BOOST_FORCEINLINE
1057         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1058         operator ()() const
1059         {
1060             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1061             return that;
1062         }
1063         
1064         
1065         template<typename A0>
1066         BOOST_FORCEINLINE
1067         typename result_of::funop1<
1068             expr const
1069           , default_domain , const A0
1070         >::type const
1071         operator ()(A0 const &a0) const
1072         {
1073             return result_of::funop1<
1074                 expr const
1075               , default_domain , const A0
1076             >::call(*this , a0);
1077         }
1078         
1079         
1080         template<typename A0 , typename A1>
1081         BOOST_FORCEINLINE
1082         typename result_of::funop2<
1083             expr const
1084           , default_domain , const A0 , const A1
1085         >::type const
1086         operator ()(A0 const &a0 , A1 const &a1) const
1087         {
1088             return result_of::funop2<
1089                 expr const
1090               , default_domain , const A0 , const A1
1091             >::call(*this , a0 , a1);
1092         }
1093         
1094         
1095         template<typename A0 , typename A1 , typename A2>
1096         BOOST_FORCEINLINE
1097         typename result_of::funop3<
1098             expr const
1099           , default_domain , const A0 , const A1 , const A2
1100         >::type const
1101         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1102         {
1103             return result_of::funop3<
1104                 expr const
1105               , default_domain , const A0 , const A1 , const A2
1106             >::call(*this , a0 , a1 , a2);
1107         }
1108         
1109         
1110         template<typename A0 , typename A1 , typename A2 , typename A3>
1111         BOOST_FORCEINLINE
1112         typename result_of::funop4<
1113             expr const
1114           , default_domain , const A0 , const A1 , const A2 , const A3
1115         >::type const
1116         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1117         {
1118             return result_of::funop4<
1119                 expr const
1120               , default_domain , const A0 , const A1 , const A2 , const A3
1121             >::call(*this , a0 , a1 , a2 , a3);
1122         }
1123         
1124         
1125         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1126         BOOST_FORCEINLINE
1127         typename result_of::funop5<
1128             expr const
1129           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1130         >::type const
1131         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1132         {
1133             return result_of::funop5<
1134                 expr const
1135               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1136             >::call(*this , a0 , a1 , a2 , a3 , a4);
1137         }
1138         
1139         
1140         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1141         BOOST_FORCEINLINE
1142         typename result_of::funop6<
1143             expr const
1144           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1145         >::type const
1146         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1147         {
1148             return result_of::funop6<
1149                 expr const
1150               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1151             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1152         }
1153         
1154         
1155         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1156         BOOST_FORCEINLINE
1157         typename result_of::funop7<
1158             expr const
1159           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1160         >::type const
1161         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1162         {
1163             return result_of::funop7<
1164                 expr const
1165               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1166             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1167         }
1168         
1169         
1170         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1171         BOOST_FORCEINLINE
1172         typename result_of::funop8<
1173             expr const
1174           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1175         >::type const
1176         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1177         {
1178             return result_of::funop8<
1179                 expr const
1180               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1181             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1182         }
1183         
1184         
1185         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1186         BOOST_FORCEINLINE
1187         typename result_of::funop9<
1188             expr const
1189           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1190         >::type const
1191         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1192         {
1193             return result_of::funop9<
1194                 expr const
1195               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1196             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1197         }
1198     };
1199     
1200     
1201     
1202     
1203     
1204     
1205     
1206     
1207     
1208     
1209     
1210     
1211     
1212     
1213     
1214     
1215     
1216     
1217     
1218     
1219     
1220     
1221     
1222     
1223     
1224     
1225     
1226     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
1227     struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
1228     {
1229         typedef Tag proto_tag;
1230         static const long proto_arity_c = 3;
1231         typedef mpl::long_<3 > proto_arity;
1232         typedef expr proto_base_expr;
1233         typedef list3<Arg0 , Arg1 , Arg2> proto_args;
1234         typedef basic_expr<Tag, proto_args, 3 > proto_grammar;
1235         typedef default_domain proto_domain;
1236         typedef default_generator proto_generator;
1237         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1238         typedef expr proto_derived_expr;
1239         typedef void proto_is_expr_; 
1240         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
1241         typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1242         
1243         
1244         BOOST_FORCEINLINE
1245         expr const &proto_base() const
1246         {
1247             return *this;
1248         }
1249         
1250         
1251         BOOST_FORCEINLINE
1252         expr &proto_base()
1253         {
1254             return *this;
1255         }
1256         
1257         
1258         
1259         template<typename A0 , typename A1 , typename A2>
1260         BOOST_FORCEINLINE
1261         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
1262         {
1263             expr that = {a0 , a1 , a2};
1264             return that;
1265         }
1266         
1267         
1268         typedef detail::not_a_valid_type address_of_hack_type_;
1269         
1270         
1271         
1272         
1273         BOOST_FORCEINLINE
1274         proto::expr<
1275             proto::tag::assign
1276           , list2<expr &, expr const &>
1277           , 2
1278         > const
1279         operator =(expr const &a)
1280         {
1281             proto::expr<
1282                 proto::tag::assign
1283               , list2<expr &, expr const &>
1284               , 2
1285             > that = {*this, a};
1286             return that;
1287         }
1288         
1289         
1290         
1291         
1292         template<typename A>
1293         BOOST_FORCEINLINE
1294         proto::expr<
1295             proto::tag::assign
1296           , list2<expr const &, typename result_of::as_child<A>::type>
1297           , 2
1298         > const
1299         operator =(A &a) const
1300         {
1301             proto::expr<
1302                 proto::tag::assign
1303               , list2<expr const &, typename result_of::as_child<A>::type>
1304               , 2
1305             > that = {*this, proto::as_child(a)};
1306             return that;
1307         }
1308         
1309         
1310         template<typename A>
1311         BOOST_FORCEINLINE
1312         proto::expr<
1313             proto::tag::assign
1314           , list2<expr const &, typename result_of::as_child<A const>::type>
1315           , 2
1316         > const
1317         operator =(A const &a) const
1318         {
1319             proto::expr<
1320                 proto::tag::assign
1321               , list2<expr const &, typename result_of::as_child<A const>::type>
1322               , 2
1323             > that = {*this, proto::as_child(a)};
1324             return that;
1325         }
1326         
1327         
1328         
1329         
1330         template<typename A>
1331         BOOST_FORCEINLINE
1332         proto::expr<
1333             proto::tag::subscript
1334           , list2<expr const &, typename result_of::as_child<A>::type>
1335           , 2
1336         > const
1337         operator [](A &a) const
1338         {
1339             proto::expr<
1340                 proto::tag::subscript
1341               , list2<expr const &, typename result_of::as_child<A>::type>
1342               , 2
1343             > that = {*this, proto::as_child(a)};
1344             return that;
1345         }
1346         
1347         
1348         template<typename A>
1349         BOOST_FORCEINLINE
1350         proto::expr<
1351             proto::tag::subscript
1352           , list2<expr const &, typename result_of::as_child<A const>::type>
1353           , 2
1354         > const
1355         operator [](A const &a) const
1356         {
1357             proto::expr<
1358                 proto::tag::subscript
1359               , list2<expr const &, typename result_of::as_child<A const>::type>
1360               , 2
1361             > that = {*this, proto::as_child(a)};
1362             return that;
1363         }
1364         
1365         
1366         template<typename Sig>
1367         struct result
1368         {
1369             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1370         };
1371         
1372         
1373         
1374         BOOST_FORCEINLINE
1375         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1376         operator ()() const
1377         {
1378             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1379             return that;
1380         }
1381         
1382         
1383         template<typename A0>
1384         BOOST_FORCEINLINE
1385         typename result_of::funop1<
1386             expr const
1387           , default_domain , const A0
1388         >::type const
1389         operator ()(A0 const &a0) const
1390         {
1391             return result_of::funop1<
1392                 expr const
1393               , default_domain , const A0
1394             >::call(*this , a0);
1395         }
1396         
1397         
1398         template<typename A0 , typename A1>
1399         BOOST_FORCEINLINE
1400         typename result_of::funop2<
1401             expr const
1402           , default_domain , const A0 , const A1
1403         >::type const
1404         operator ()(A0 const &a0 , A1 const &a1) const
1405         {
1406             return result_of::funop2<
1407                 expr const
1408               , default_domain , const A0 , const A1
1409             >::call(*this , a0 , a1);
1410         }
1411         
1412         
1413         template<typename A0 , typename A1 , typename A2>
1414         BOOST_FORCEINLINE
1415         typename result_of::funop3<
1416             expr const
1417           , default_domain , const A0 , const A1 , const A2
1418         >::type const
1419         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1420         {
1421             return result_of::funop3<
1422                 expr const
1423               , default_domain , const A0 , const A1 , const A2
1424             >::call(*this , a0 , a1 , a2);
1425         }
1426         
1427         
1428         template<typename A0 , typename A1 , typename A2 , typename A3>
1429         BOOST_FORCEINLINE
1430         typename result_of::funop4<
1431             expr const
1432           , default_domain , const A0 , const A1 , const A2 , const A3
1433         >::type const
1434         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1435         {
1436             return result_of::funop4<
1437                 expr const
1438               , default_domain , const A0 , const A1 , const A2 , const A3
1439             >::call(*this , a0 , a1 , a2 , a3);
1440         }
1441         
1442         
1443         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1444         BOOST_FORCEINLINE
1445         typename result_of::funop5<
1446             expr const
1447           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1448         >::type const
1449         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1450         {
1451             return result_of::funop5<
1452                 expr const
1453               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1454             >::call(*this , a0 , a1 , a2 , a3 , a4);
1455         }
1456         
1457         
1458         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1459         BOOST_FORCEINLINE
1460         typename result_of::funop6<
1461             expr const
1462           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1463         >::type const
1464         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1465         {
1466             return result_of::funop6<
1467                 expr const
1468               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1469             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1470         }
1471         
1472         
1473         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1474         BOOST_FORCEINLINE
1475         typename result_of::funop7<
1476             expr const
1477           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1478         >::type const
1479         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1480         {
1481             return result_of::funop7<
1482                 expr const
1483               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1484             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1485         }
1486         
1487         
1488         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1489         BOOST_FORCEINLINE
1490         typename result_of::funop8<
1491             expr const
1492           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1493         >::type const
1494         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1495         {
1496             return result_of::funop8<
1497                 expr const
1498               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1499             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1500         }
1501         
1502         
1503         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1504         BOOST_FORCEINLINE
1505         typename result_of::funop9<
1506             expr const
1507           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1508         >::type const
1509         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1510         {
1511             return result_of::funop9<
1512                 expr const
1513               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1514             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1515         }
1516     };
1517     
1518     
1519     
1520     
1521     
1522     
1523     
1524     
1525     
1526     
1527     
1528     
1529     
1530     
1531     
1532     
1533     
1534     
1535     
1536     
1537     
1538     
1539     
1540     
1541     
1542     
1543     
1544     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
1545     struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
1546     {
1547         typedef Tag proto_tag;
1548         static const long proto_arity_c = 4;
1549         typedef mpl::long_<4 > proto_arity;
1550         typedef expr proto_base_expr;
1551         typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
1552         typedef basic_expr<Tag, proto_args, 4 > proto_grammar;
1553         typedef default_domain proto_domain;
1554         typedef default_generator proto_generator;
1555         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1556         typedef expr proto_derived_expr;
1557         typedef void proto_is_expr_; 
1558         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
1559         typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1560         
1561         
1562         BOOST_FORCEINLINE
1563         expr const &proto_base() const
1564         {
1565             return *this;
1566         }
1567         
1568         
1569         BOOST_FORCEINLINE
1570         expr &proto_base()
1571         {
1572             return *this;
1573         }
1574         
1575         
1576         
1577         template<typename A0 , typename A1 , typename A2 , typename A3>
1578         BOOST_FORCEINLINE
1579         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
1580         {
1581             expr that = {a0 , a1 , a2 , a3};
1582             return that;
1583         }
1584         
1585         
1586         typedef detail::not_a_valid_type address_of_hack_type_;
1587         
1588         
1589         
1590         
1591         BOOST_FORCEINLINE
1592         proto::expr<
1593             proto::tag::assign
1594           , list2<expr &, expr const &>
1595           , 2
1596         > const
1597         operator =(expr const &a)
1598         {
1599             proto::expr<
1600                 proto::tag::assign
1601               , list2<expr &, expr const &>
1602               , 2
1603             > that = {*this, a};
1604             return that;
1605         }
1606         
1607         
1608         
1609         
1610         template<typename A>
1611         BOOST_FORCEINLINE
1612         proto::expr<
1613             proto::tag::assign
1614           , list2<expr const &, typename result_of::as_child<A>::type>
1615           , 2
1616         > const
1617         operator =(A &a) const
1618         {
1619             proto::expr<
1620                 proto::tag::assign
1621               , list2<expr const &, typename result_of::as_child<A>::type>
1622               , 2
1623             > that = {*this, proto::as_child(a)};
1624             return that;
1625         }
1626         
1627         
1628         template<typename A>
1629         BOOST_FORCEINLINE
1630         proto::expr<
1631             proto::tag::assign
1632           , list2<expr const &, typename result_of::as_child<A const>::type>
1633           , 2
1634         > const
1635         operator =(A const &a) const
1636         {
1637             proto::expr<
1638                 proto::tag::assign
1639               , list2<expr const &, typename result_of::as_child<A const>::type>
1640               , 2
1641             > that = {*this, proto::as_child(a)};
1642             return that;
1643         }
1644         
1645         
1646         
1647         
1648         template<typename A>
1649         BOOST_FORCEINLINE
1650         proto::expr<
1651             proto::tag::subscript
1652           , list2<expr const &, typename result_of::as_child<A>::type>
1653           , 2
1654         > const
1655         operator [](A &a) const
1656         {
1657             proto::expr<
1658                 proto::tag::subscript
1659               , list2<expr const &, typename result_of::as_child<A>::type>
1660               , 2
1661             > that = {*this, proto::as_child(a)};
1662             return that;
1663         }
1664         
1665         
1666         template<typename A>
1667         BOOST_FORCEINLINE
1668         proto::expr<
1669             proto::tag::subscript
1670           , list2<expr const &, typename result_of::as_child<A const>::type>
1671           , 2
1672         > const
1673         operator [](A const &a) const
1674         {
1675             proto::expr<
1676                 proto::tag::subscript
1677               , list2<expr const &, typename result_of::as_child<A const>::type>
1678               , 2
1679             > that = {*this, proto::as_child(a)};
1680             return that;
1681         }
1682         
1683         
1684         template<typename Sig>
1685         struct result
1686         {
1687             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
1688         };
1689         
1690         
1691         
1692         BOOST_FORCEINLINE
1693         proto::expr<proto::tag::function, list1<expr const &>, 1> const
1694         operator ()() const
1695         {
1696             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
1697             return that;
1698         }
1699         
1700         
1701         template<typename A0>
1702         BOOST_FORCEINLINE
1703         typename result_of::funop1<
1704             expr const
1705           , default_domain , const A0
1706         >::type const
1707         operator ()(A0 const &a0) const
1708         {
1709             return result_of::funop1<
1710                 expr const
1711               , default_domain , const A0
1712             >::call(*this , a0);
1713         }
1714         
1715         
1716         template<typename A0 , typename A1>
1717         BOOST_FORCEINLINE
1718         typename result_of::funop2<
1719             expr const
1720           , default_domain , const A0 , const A1
1721         >::type const
1722         operator ()(A0 const &a0 , A1 const &a1) const
1723         {
1724             return result_of::funop2<
1725                 expr const
1726               , default_domain , const A0 , const A1
1727             >::call(*this , a0 , a1);
1728         }
1729         
1730         
1731         template<typename A0 , typename A1 , typename A2>
1732         BOOST_FORCEINLINE
1733         typename result_of::funop3<
1734             expr const
1735           , default_domain , const A0 , const A1 , const A2
1736         >::type const
1737         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
1738         {
1739             return result_of::funop3<
1740                 expr const
1741               , default_domain , const A0 , const A1 , const A2
1742             >::call(*this , a0 , a1 , a2);
1743         }
1744         
1745         
1746         template<typename A0 , typename A1 , typename A2 , typename A3>
1747         BOOST_FORCEINLINE
1748         typename result_of::funop4<
1749             expr const
1750           , default_domain , const A0 , const A1 , const A2 , const A3
1751         >::type const
1752         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
1753         {
1754             return result_of::funop4<
1755                 expr const
1756               , default_domain , const A0 , const A1 , const A2 , const A3
1757             >::call(*this , a0 , a1 , a2 , a3);
1758         }
1759         
1760         
1761         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1762         BOOST_FORCEINLINE
1763         typename result_of::funop5<
1764             expr const
1765           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1766         >::type const
1767         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
1768         {
1769             return result_of::funop5<
1770                 expr const
1771               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
1772             >::call(*this , a0 , a1 , a2 , a3 , a4);
1773         }
1774         
1775         
1776         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
1777         BOOST_FORCEINLINE
1778         typename result_of::funop6<
1779             expr const
1780           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1781         >::type const
1782         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
1783         {
1784             return result_of::funop6<
1785                 expr const
1786               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
1787             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
1788         }
1789         
1790         
1791         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
1792         BOOST_FORCEINLINE
1793         typename result_of::funop7<
1794             expr const
1795           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1796         >::type const
1797         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
1798         {
1799             return result_of::funop7<
1800                 expr const
1801               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
1802             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
1803         }
1804         
1805         
1806         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1807         BOOST_FORCEINLINE
1808         typename result_of::funop8<
1809             expr const
1810           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1811         >::type const
1812         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
1813         {
1814             return result_of::funop8<
1815                 expr const
1816               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
1817             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1818         }
1819         
1820         
1821         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1822         BOOST_FORCEINLINE
1823         typename result_of::funop9<
1824             expr const
1825           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1826         >::type const
1827         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
1828         {
1829             return result_of::funop9<
1830                 expr const
1831               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
1832             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1833         }
1834     };
1835     
1836     
1837     
1838     
1839     
1840     
1841     
1842     
1843     
1844     
1845     
1846     
1847     
1848     
1849     
1850     
1851     
1852     
1853     
1854     
1855     
1856     
1857     
1858     
1859     
1860     
1861     
1862     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
1863     struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
1864     {
1865         typedef Tag proto_tag;
1866         static const long proto_arity_c = 5;
1867         typedef mpl::long_<5 > proto_arity;
1868         typedef expr proto_base_expr;
1869         typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
1870         typedef basic_expr<Tag, proto_args, 5 > proto_grammar;
1871         typedef default_domain proto_domain;
1872         typedef default_generator proto_generator;
1873         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
1874         typedef expr proto_derived_expr;
1875         typedef void proto_is_expr_; 
1876         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
1877         typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
1878         
1879         
1880         BOOST_FORCEINLINE
1881         expr const &proto_base() const
1882         {
1883             return *this;
1884         }
1885         
1886         
1887         BOOST_FORCEINLINE
1888         expr &proto_base()
1889         {
1890             return *this;
1891         }
1892         
1893         
1894         
1895         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
1896         BOOST_FORCEINLINE
1897         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
1898         {
1899             expr that = {a0 , a1 , a2 , a3 , a4};
1900             return that;
1901         }
1902         
1903         
1904         typedef detail::not_a_valid_type address_of_hack_type_;
1905         
1906         
1907         
1908         
1909         BOOST_FORCEINLINE
1910         proto::expr<
1911             proto::tag::assign
1912           , list2<expr &, expr const &>
1913           , 2
1914         > const
1915         operator =(expr const &a)
1916         {
1917             proto::expr<
1918                 proto::tag::assign
1919               , list2<expr &, expr const &>
1920               , 2
1921             > that = {*this, a};
1922             return that;
1923         }
1924         
1925         
1926         
1927         
1928         template<typename A>
1929         BOOST_FORCEINLINE
1930         proto::expr<
1931             proto::tag::assign
1932           , list2<expr const &, typename result_of::as_child<A>::type>
1933           , 2
1934         > const
1935         operator =(A &a) const
1936         {
1937             proto::expr<
1938                 proto::tag::assign
1939               , list2<expr const &, typename result_of::as_child<A>::type>
1940               , 2
1941             > that = {*this, proto::as_child(a)};
1942             return that;
1943         }
1944         
1945         
1946         template<typename A>
1947         BOOST_FORCEINLINE
1948         proto::expr<
1949             proto::tag::assign
1950           , list2<expr const &, typename result_of::as_child<A const>::type>
1951           , 2
1952         > const
1953         operator =(A const &a) const
1954         {
1955             proto::expr<
1956                 proto::tag::assign
1957               , list2<expr const &, typename result_of::as_child<A const>::type>
1958               , 2
1959             > that = {*this, proto::as_child(a)};
1960             return that;
1961         }
1962         
1963         
1964         
1965         
1966         template<typename A>
1967         BOOST_FORCEINLINE
1968         proto::expr<
1969             proto::tag::subscript
1970           , list2<expr const &, typename result_of::as_child<A>::type>
1971           , 2
1972         > const
1973         operator [](A &a) const
1974         {
1975             proto::expr<
1976                 proto::tag::subscript
1977               , list2<expr const &, typename result_of::as_child<A>::type>
1978               , 2
1979             > that = {*this, proto::as_child(a)};
1980             return that;
1981         }
1982         
1983         
1984         template<typename A>
1985         BOOST_FORCEINLINE
1986         proto::expr<
1987             proto::tag::subscript
1988           , list2<expr const &, typename result_of::as_child<A const>::type>
1989           , 2
1990         > const
1991         operator [](A const &a) const
1992         {
1993             proto::expr<
1994                 proto::tag::subscript
1995               , list2<expr const &, typename result_of::as_child<A const>::type>
1996               , 2
1997             > that = {*this, proto::as_child(a)};
1998             return that;
1999         }
2000         
2001         
2002         template<typename Sig>
2003         struct result
2004         {
2005             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2006         };
2007         
2008         
2009         
2010         BOOST_FORCEINLINE
2011         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2012         operator ()() const
2013         {
2014             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2015             return that;
2016         }
2017         
2018         
2019         template<typename A0>
2020         BOOST_FORCEINLINE
2021         typename result_of::funop1<
2022             expr const
2023           , default_domain , const A0
2024         >::type const
2025         operator ()(A0 const &a0) const
2026         {
2027             return result_of::funop1<
2028                 expr const
2029               , default_domain , const A0
2030             >::call(*this , a0);
2031         }
2032         
2033         
2034         template<typename A0 , typename A1>
2035         BOOST_FORCEINLINE
2036         typename result_of::funop2<
2037             expr const
2038           , default_domain , const A0 , const A1
2039         >::type const
2040         operator ()(A0 const &a0 , A1 const &a1) const
2041         {
2042             return result_of::funop2<
2043                 expr const
2044               , default_domain , const A0 , const A1
2045             >::call(*this , a0 , a1);
2046         }
2047         
2048         
2049         template<typename A0 , typename A1 , typename A2>
2050         BOOST_FORCEINLINE
2051         typename result_of::funop3<
2052             expr const
2053           , default_domain , const A0 , const A1 , const A2
2054         >::type const
2055         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2056         {
2057             return result_of::funop3<
2058                 expr const
2059               , default_domain , const A0 , const A1 , const A2
2060             >::call(*this , a0 , a1 , a2);
2061         }
2062         
2063         
2064         template<typename A0 , typename A1 , typename A2 , typename A3>
2065         BOOST_FORCEINLINE
2066         typename result_of::funop4<
2067             expr const
2068           , default_domain , const A0 , const A1 , const A2 , const A3
2069         >::type const
2070         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2071         {
2072             return result_of::funop4<
2073                 expr const
2074               , default_domain , const A0 , const A1 , const A2 , const A3
2075             >::call(*this , a0 , a1 , a2 , a3);
2076         }
2077         
2078         
2079         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2080         BOOST_FORCEINLINE
2081         typename result_of::funop5<
2082             expr const
2083           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2084         >::type const
2085         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2086         {
2087             return result_of::funop5<
2088                 expr const
2089               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2090             >::call(*this , a0 , a1 , a2 , a3 , a4);
2091         }
2092         
2093         
2094         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2095         BOOST_FORCEINLINE
2096         typename result_of::funop6<
2097             expr const
2098           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2099         >::type const
2100         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2101         {
2102             return result_of::funop6<
2103                 expr const
2104               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2105             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2106         }
2107         
2108         
2109         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2110         BOOST_FORCEINLINE
2111         typename result_of::funop7<
2112             expr const
2113           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2114         >::type const
2115         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2116         {
2117             return result_of::funop7<
2118                 expr const
2119               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2120             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2121         }
2122         
2123         
2124         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2125         BOOST_FORCEINLINE
2126         typename result_of::funop8<
2127             expr const
2128           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2129         >::type const
2130         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2131         {
2132             return result_of::funop8<
2133                 expr const
2134               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2135             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2136         }
2137         
2138         
2139         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2140         BOOST_FORCEINLINE
2141         typename result_of::funop9<
2142             expr const
2143           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2144         >::type const
2145         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2146         {
2147             return result_of::funop9<
2148                 expr const
2149               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2150             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2151         }
2152     };
2153     
2154     
2155     
2156     
2157     
2158     
2159     
2160     
2161     
2162     
2163     
2164     
2165     
2166     
2167     
2168     
2169     
2170     
2171     
2172     
2173     
2174     
2175     
2176     
2177     
2178     
2179     
2180     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
2181     struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
2182     {
2183         typedef Tag proto_tag;
2184         static const long proto_arity_c = 6;
2185         typedef mpl::long_<6 > proto_arity;
2186         typedef expr proto_base_expr;
2187         typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
2188         typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
2189         typedef default_domain proto_domain;
2190         typedef default_generator proto_generator;
2191         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
2192         typedef expr proto_derived_expr;
2193         typedef void proto_is_expr_; 
2194         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
2195         typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
2196         
2197         
2198         BOOST_FORCEINLINE
2199         expr const &proto_base() const
2200         {
2201             return *this;
2202         }
2203         
2204         
2205         BOOST_FORCEINLINE
2206         expr &proto_base()
2207         {
2208             return *this;
2209         }
2210         
2211         
2212         
2213         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2214         BOOST_FORCEINLINE
2215         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
2216         {
2217             expr that = {a0 , a1 , a2 , a3 , a4 , a5};
2218             return that;
2219         }
2220         
2221         
2222         typedef detail::not_a_valid_type address_of_hack_type_;
2223         
2224         
2225         
2226         
2227         BOOST_FORCEINLINE
2228         proto::expr<
2229             proto::tag::assign
2230           , list2<expr &, expr const &>
2231           , 2
2232         > const
2233         operator =(expr const &a)
2234         {
2235             proto::expr<
2236                 proto::tag::assign
2237               , list2<expr &, expr const &>
2238               , 2
2239             > that = {*this, a};
2240             return that;
2241         }
2242         
2243         
2244         
2245         
2246         template<typename A>
2247         BOOST_FORCEINLINE
2248         proto::expr<
2249             proto::tag::assign
2250           , list2<expr const &, typename result_of::as_child<A>::type>
2251           , 2
2252         > const
2253         operator =(A &a) const
2254         {
2255             proto::expr<
2256                 proto::tag::assign
2257               , list2<expr const &, typename result_of::as_child<A>::type>
2258               , 2
2259             > that = {*this, proto::as_child(a)};
2260             return that;
2261         }
2262         
2263         
2264         template<typename A>
2265         BOOST_FORCEINLINE
2266         proto::expr<
2267             proto::tag::assign
2268           , list2<expr const &, typename result_of::as_child<A const>::type>
2269           , 2
2270         > const
2271         operator =(A const &a) const
2272         {
2273             proto::expr<
2274                 proto::tag::assign
2275               , list2<expr const &, typename result_of::as_child<A const>::type>
2276               , 2
2277             > that = {*this, proto::as_child(a)};
2278             return that;
2279         }
2280         
2281         
2282         
2283         
2284         template<typename A>
2285         BOOST_FORCEINLINE
2286         proto::expr<
2287             proto::tag::subscript
2288           , list2<expr const &, typename result_of::as_child<A>::type>
2289           , 2
2290         > const
2291         operator [](A &a) const
2292         {
2293             proto::expr<
2294                 proto::tag::subscript
2295               , list2<expr const &, typename result_of::as_child<A>::type>
2296               , 2
2297             > that = {*this, proto::as_child(a)};
2298             return that;
2299         }
2300         
2301         
2302         template<typename A>
2303         BOOST_FORCEINLINE
2304         proto::expr<
2305             proto::tag::subscript
2306           , list2<expr const &, typename result_of::as_child<A const>::type>
2307           , 2
2308         > const
2309         operator [](A const &a) const
2310         {
2311             proto::expr<
2312                 proto::tag::subscript
2313               , list2<expr const &, typename result_of::as_child<A const>::type>
2314               , 2
2315             > that = {*this, proto::as_child(a)};
2316             return that;
2317         }
2318         
2319         
2320         template<typename Sig>
2321         struct result
2322         {
2323             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2324         };
2325         
2326         
2327         
2328         BOOST_FORCEINLINE
2329         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2330         operator ()() const
2331         {
2332             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2333             return that;
2334         }
2335         
2336         
2337         template<typename A0>
2338         BOOST_FORCEINLINE
2339         typename result_of::funop1<
2340             expr const
2341           , default_domain , const A0
2342         >::type const
2343         operator ()(A0 const &a0) const
2344         {
2345             return result_of::funop1<
2346                 expr const
2347               , default_domain , const A0
2348             >::call(*this , a0);
2349         }
2350         
2351         
2352         template<typename A0 , typename A1>
2353         BOOST_FORCEINLINE
2354         typename result_of::funop2<
2355             expr const
2356           , default_domain , const A0 , const A1
2357         >::type const
2358         operator ()(A0 const &a0 , A1 const &a1) const
2359         {
2360             return result_of::funop2<
2361                 expr const
2362               , default_domain , const A0 , const A1
2363             >::call(*this , a0 , a1);
2364         }
2365         
2366         
2367         template<typename A0 , typename A1 , typename A2>
2368         BOOST_FORCEINLINE
2369         typename result_of::funop3<
2370             expr const
2371           , default_domain , const A0 , const A1 , const A2
2372         >::type const
2373         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2374         {
2375             return result_of::funop3<
2376                 expr const
2377               , default_domain , const A0 , const A1 , const A2
2378             >::call(*this , a0 , a1 , a2);
2379         }
2380         
2381         
2382         template<typename A0 , typename A1 , typename A2 , typename A3>
2383         BOOST_FORCEINLINE
2384         typename result_of::funop4<
2385             expr const
2386           , default_domain , const A0 , const A1 , const A2 , const A3
2387         >::type const
2388         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2389         {
2390             return result_of::funop4<
2391                 expr const
2392               , default_domain , const A0 , const A1 , const A2 , const A3
2393             >::call(*this , a0 , a1 , a2 , a3);
2394         }
2395         
2396         
2397         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2398         BOOST_FORCEINLINE
2399         typename result_of::funop5<
2400             expr const
2401           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2402         >::type const
2403         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2404         {
2405             return result_of::funop5<
2406                 expr const
2407               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2408             >::call(*this , a0 , a1 , a2 , a3 , a4);
2409         }
2410         
2411         
2412         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2413         BOOST_FORCEINLINE
2414         typename result_of::funop6<
2415             expr const
2416           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2417         >::type const
2418         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2419         {
2420             return result_of::funop6<
2421                 expr const
2422               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2423             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2424         }
2425         
2426         
2427         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2428         BOOST_FORCEINLINE
2429         typename result_of::funop7<
2430             expr const
2431           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2432         >::type const
2433         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2434         {
2435             return result_of::funop7<
2436                 expr const
2437               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2438             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2439         }
2440         
2441         
2442         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2443         BOOST_FORCEINLINE
2444         typename result_of::funop8<
2445             expr const
2446           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2447         >::type const
2448         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2449         {
2450             return result_of::funop8<
2451                 expr const
2452               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2453             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2454         }
2455         
2456         
2457         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2458         BOOST_FORCEINLINE
2459         typename result_of::funop9<
2460             expr const
2461           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2462         >::type const
2463         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2464         {
2465             return result_of::funop9<
2466                 expr const
2467               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2468             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2469         }
2470     };
2471     
2472     
2473     
2474     
2475     
2476     
2477     
2478     
2479     
2480     
2481     
2482     
2483     
2484     
2485     
2486     
2487     
2488     
2489     
2490     
2491     
2492     
2493     
2494     
2495     
2496     
2497     
2498     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
2499     struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
2500     {
2501         typedef Tag proto_tag;
2502         static const long proto_arity_c = 7;
2503         typedef mpl::long_<7 > proto_arity;
2504         typedef expr proto_base_expr;
2505         typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
2506         typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
2507         typedef default_domain proto_domain;
2508         typedef default_generator proto_generator;
2509         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
2510         typedef expr proto_derived_expr;
2511         typedef void proto_is_expr_; 
2512         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
2513         typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
2514         
2515         
2516         BOOST_FORCEINLINE
2517         expr const &proto_base() const
2518         {
2519             return *this;
2520         }
2521         
2522         
2523         BOOST_FORCEINLINE
2524         expr &proto_base()
2525         {
2526             return *this;
2527         }
2528         
2529         
2530         
2531         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2532         BOOST_FORCEINLINE
2533         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
2534         {
2535             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
2536             return that;
2537         }
2538         
2539         
2540         typedef detail::not_a_valid_type address_of_hack_type_;
2541         
2542         
2543         
2544         
2545         BOOST_FORCEINLINE
2546         proto::expr<
2547             proto::tag::assign
2548           , list2<expr &, expr const &>
2549           , 2
2550         > const
2551         operator =(expr const &a)
2552         {
2553             proto::expr<
2554                 proto::tag::assign
2555               , list2<expr &, expr const &>
2556               , 2
2557             > that = {*this, a};
2558             return that;
2559         }
2560         
2561         
2562         
2563         
2564         template<typename A>
2565         BOOST_FORCEINLINE
2566         proto::expr<
2567             proto::tag::assign
2568           , list2<expr const &, typename result_of::as_child<A>::type>
2569           , 2
2570         > const
2571         operator =(A &a) const
2572         {
2573             proto::expr<
2574                 proto::tag::assign
2575               , list2<expr const &, typename result_of::as_child<A>::type>
2576               , 2
2577             > that = {*this, proto::as_child(a)};
2578             return that;
2579         }
2580         
2581         
2582         template<typename A>
2583         BOOST_FORCEINLINE
2584         proto::expr<
2585             proto::tag::assign
2586           , list2<expr const &, typename result_of::as_child<A const>::type>
2587           , 2
2588         > const
2589         operator =(A const &a) const
2590         {
2591             proto::expr<
2592                 proto::tag::assign
2593               , list2<expr const &, typename result_of::as_child<A const>::type>
2594               , 2
2595             > that = {*this, proto::as_child(a)};
2596             return that;
2597         }
2598         
2599         
2600         
2601         
2602         template<typename A>
2603         BOOST_FORCEINLINE
2604         proto::expr<
2605             proto::tag::subscript
2606           , list2<expr const &, typename result_of::as_child<A>::type>
2607           , 2
2608         > const
2609         operator [](A &a) const
2610         {
2611             proto::expr<
2612                 proto::tag::subscript
2613               , list2<expr const &, typename result_of::as_child<A>::type>
2614               , 2
2615             > that = {*this, proto::as_child(a)};
2616             return that;
2617         }
2618         
2619         
2620         template<typename A>
2621         BOOST_FORCEINLINE
2622         proto::expr<
2623             proto::tag::subscript
2624           , list2<expr const &, typename result_of::as_child<A const>::type>
2625           , 2
2626         > const
2627         operator [](A const &a) const
2628         {
2629             proto::expr<
2630                 proto::tag::subscript
2631               , list2<expr const &, typename result_of::as_child<A const>::type>
2632               , 2
2633             > that = {*this, proto::as_child(a)};
2634             return that;
2635         }
2636         
2637         
2638         template<typename Sig>
2639         struct result
2640         {
2641             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2642         };
2643         
2644         
2645         
2646         BOOST_FORCEINLINE
2647         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2648         operator ()() const
2649         {
2650             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2651             return that;
2652         }
2653         
2654         
2655         template<typename A0>
2656         BOOST_FORCEINLINE
2657         typename result_of::funop1<
2658             expr const
2659           , default_domain , const A0
2660         >::type const
2661         operator ()(A0 const &a0) const
2662         {
2663             return result_of::funop1<
2664                 expr const
2665               , default_domain , const A0
2666             >::call(*this , a0);
2667         }
2668         
2669         
2670         template<typename A0 , typename A1>
2671         BOOST_FORCEINLINE
2672         typename result_of::funop2<
2673             expr const
2674           , default_domain , const A0 , const A1
2675         >::type const
2676         operator ()(A0 const &a0 , A1 const &a1) const
2677         {
2678             return result_of::funop2<
2679                 expr const
2680               , default_domain , const A0 , const A1
2681             >::call(*this , a0 , a1);
2682         }
2683         
2684         
2685         template<typename A0 , typename A1 , typename A2>
2686         BOOST_FORCEINLINE
2687         typename result_of::funop3<
2688             expr const
2689           , default_domain , const A0 , const A1 , const A2
2690         >::type const
2691         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
2692         {
2693             return result_of::funop3<
2694                 expr const
2695               , default_domain , const A0 , const A1 , const A2
2696             >::call(*this , a0 , a1 , a2);
2697         }
2698         
2699         
2700         template<typename A0 , typename A1 , typename A2 , typename A3>
2701         BOOST_FORCEINLINE
2702         typename result_of::funop4<
2703             expr const
2704           , default_domain , const A0 , const A1 , const A2 , const A3
2705         >::type const
2706         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
2707         {
2708             return result_of::funop4<
2709                 expr const
2710               , default_domain , const A0 , const A1 , const A2 , const A3
2711             >::call(*this , a0 , a1 , a2 , a3);
2712         }
2713         
2714         
2715         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
2716         BOOST_FORCEINLINE
2717         typename result_of::funop5<
2718             expr const
2719           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2720         >::type const
2721         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
2722         {
2723             return result_of::funop5<
2724                 expr const
2725               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
2726             >::call(*this , a0 , a1 , a2 , a3 , a4);
2727         }
2728         
2729         
2730         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
2731         BOOST_FORCEINLINE
2732         typename result_of::funop6<
2733             expr const
2734           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2735         >::type const
2736         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
2737         {
2738             return result_of::funop6<
2739                 expr const
2740               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
2741             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
2742         }
2743         
2744         
2745         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
2746         BOOST_FORCEINLINE
2747         typename result_of::funop7<
2748             expr const
2749           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2750         >::type const
2751         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
2752         {
2753             return result_of::funop7<
2754                 expr const
2755               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
2756             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
2757         }
2758         
2759         
2760         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2761         BOOST_FORCEINLINE
2762         typename result_of::funop8<
2763             expr const
2764           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2765         >::type const
2766         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
2767         {
2768             return result_of::funop8<
2769                 expr const
2770               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
2771             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
2772         }
2773         
2774         
2775         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
2776         BOOST_FORCEINLINE
2777         typename result_of::funop9<
2778             expr const
2779           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2780         >::type const
2781         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
2782         {
2783             return result_of::funop9<
2784                 expr const
2785               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
2786             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
2787         }
2788     };
2789     
2790     
2791     
2792     
2793     
2794     
2795     
2796     
2797     
2798     
2799     
2800     
2801     
2802     
2803     
2804     
2805     
2806     
2807     
2808     
2809     
2810     
2811     
2812     
2813     
2814     
2815     
2816     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
2817     struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
2818     {
2819         typedef Tag proto_tag;
2820         static const long proto_arity_c = 8;
2821         typedef mpl::long_<8 > proto_arity;
2822         typedef expr proto_base_expr;
2823         typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
2824         typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
2825         typedef default_domain proto_domain;
2826         typedef default_generator proto_generator;
2827         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
2828         typedef expr proto_derived_expr;
2829         typedef void proto_is_expr_; 
2830         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
2831         typedef void proto_child8; typedef void proto_child9;
2832         
2833         
2834         BOOST_FORCEINLINE
2835         expr const &proto_base() const
2836         {
2837             return *this;
2838         }
2839         
2840         
2841         BOOST_FORCEINLINE
2842         expr &proto_base()
2843         {
2844             return *this;
2845         }
2846         
2847         
2848         
2849         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
2850         BOOST_FORCEINLINE
2851         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
2852         {
2853             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
2854             return that;
2855         }
2856         
2857         
2858         typedef detail::not_a_valid_type address_of_hack_type_;
2859         
2860         
2861         
2862         
2863         BOOST_FORCEINLINE
2864         proto::expr<
2865             proto::tag::assign
2866           , list2<expr &, expr const &>
2867           , 2
2868         > const
2869         operator =(expr const &a)
2870         {
2871             proto::expr<
2872                 proto::tag::assign
2873               , list2<expr &, expr const &>
2874               , 2
2875             > that = {*this, a};
2876             return that;
2877         }
2878         
2879         
2880         
2881         
2882         template<typename A>
2883         BOOST_FORCEINLINE
2884         proto::expr<
2885             proto::tag::assign
2886           , list2<expr const &, typename result_of::as_child<A>::type>
2887           , 2
2888         > const
2889         operator =(A &a) const
2890         {
2891             proto::expr<
2892                 proto::tag::assign
2893               , list2<expr const &, typename result_of::as_child<A>::type>
2894               , 2
2895             > that = {*this, proto::as_child(a)};
2896             return that;
2897         }
2898         
2899         
2900         template<typename A>
2901         BOOST_FORCEINLINE
2902         proto::expr<
2903             proto::tag::assign
2904           , list2<expr const &, typename result_of::as_child<A const>::type>
2905           , 2
2906         > const
2907         operator =(A const &a) const
2908         {
2909             proto::expr<
2910                 proto::tag::assign
2911               , list2<expr const &, typename result_of::as_child<A const>::type>
2912               , 2
2913             > that = {*this, proto::as_child(a)};
2914             return that;
2915         }
2916         
2917         
2918         
2919         
2920         template<typename A>
2921         BOOST_FORCEINLINE
2922         proto::expr<
2923             proto::tag::subscript
2924           , list2<expr const &, typename result_of::as_child<A>::type>
2925           , 2
2926         > const
2927         operator [](A &a) const
2928         {
2929             proto::expr<
2930                 proto::tag::subscript
2931               , list2<expr const &, typename result_of::as_child<A>::type>
2932               , 2
2933             > that = {*this, proto::as_child(a)};
2934             return that;
2935         }
2936         
2937         
2938         template<typename A>
2939         BOOST_FORCEINLINE
2940         proto::expr<
2941             proto::tag::subscript
2942           , list2<expr const &, typename result_of::as_child<A const>::type>
2943           , 2
2944         > const
2945         operator [](A const &a) const
2946         {
2947             proto::expr<
2948                 proto::tag::subscript
2949               , list2<expr const &, typename result_of::as_child<A const>::type>
2950               , 2
2951             > that = {*this, proto::as_child(a)};
2952             return that;
2953         }
2954         
2955         
2956         template<typename Sig>
2957         struct result
2958         {
2959             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
2960         };
2961         
2962         
2963         
2964         BOOST_FORCEINLINE
2965         proto::expr<proto::tag::function, list1<expr const &>, 1> const
2966         operator ()() const
2967         {
2968             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
2969             return that;
2970         }
2971         
2972         
2973         template<typename A0>
2974         BOOST_FORCEINLINE
2975         typename result_of::funop1<
2976             expr const
2977           , default_domain , const A0
2978         >::type const
2979         operator ()(A0 const &a0) const
2980         {
2981             return result_of::funop1<
2982                 expr const
2983               , default_domain , const A0
2984             >::call(*this , a0);
2985         }
2986         
2987         
2988         template<typename A0 , typename A1>
2989         BOOST_FORCEINLINE
2990         typename result_of::funop2<
2991             expr const
2992           , default_domain , const A0 , const A1
2993         >::type const
2994         operator ()(A0 const &a0 , A1 const &a1) const
2995         {
2996             return result_of::funop2<
2997                 expr const
2998               , default_domain , const A0 , const A1
2999             >::call(*this , a0 , a1);
3000         }
3001         
3002         
3003         template<typename A0 , typename A1 , typename A2>
3004         BOOST_FORCEINLINE
3005         typename result_of::funop3<
3006             expr const
3007           , default_domain , const A0 , const A1 , const A2
3008         >::type const
3009         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3010         {
3011             return result_of::funop3<
3012                 expr const
3013               , default_domain , const A0 , const A1 , const A2
3014             >::call(*this , a0 , a1 , a2);
3015         }
3016         
3017         
3018         template<typename A0 , typename A1 , typename A2 , typename A3>
3019         BOOST_FORCEINLINE
3020         typename result_of::funop4<
3021             expr const
3022           , default_domain , const A0 , const A1 , const A2 , const A3
3023         >::type const
3024         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3025         {
3026             return result_of::funop4<
3027                 expr const
3028               , default_domain , const A0 , const A1 , const A2 , const A3
3029             >::call(*this , a0 , a1 , a2 , a3);
3030         }
3031         
3032         
3033         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3034         BOOST_FORCEINLINE
3035         typename result_of::funop5<
3036             expr const
3037           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3038         >::type const
3039         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3040         {
3041             return result_of::funop5<
3042                 expr const
3043               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3044             >::call(*this , a0 , a1 , a2 , a3 , a4);
3045         }
3046         
3047         
3048         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3049         BOOST_FORCEINLINE
3050         typename result_of::funop6<
3051             expr const
3052           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3053         >::type const
3054         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3055         {
3056             return result_of::funop6<
3057                 expr const
3058               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3059             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3060         }
3061         
3062         
3063         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3064         BOOST_FORCEINLINE
3065         typename result_of::funop7<
3066             expr const
3067           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3068         >::type const
3069         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3070         {
3071             return result_of::funop7<
3072                 expr const
3073               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3074             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3075         }
3076         
3077         
3078         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3079         BOOST_FORCEINLINE
3080         typename result_of::funop8<
3081             expr const
3082           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3083         >::type const
3084         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3085         {
3086             return result_of::funop8<
3087                 expr const
3088               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3089             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3090         }
3091         
3092         
3093         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3094         BOOST_FORCEINLINE
3095         typename result_of::funop9<
3096             expr const
3097           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3098         >::type const
3099         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3100         {
3101             return result_of::funop9<
3102                 expr const
3103               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3104             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3105         }
3106     };
3107     
3108     
3109     
3110     
3111     
3112     
3113     
3114     
3115     
3116     
3117     
3118     
3119     
3120     
3121     
3122     
3123     
3124     
3125     
3126     
3127     
3128     
3129     
3130     
3131     
3132     
3133     
3134     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
3135     struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
3136     {
3137         typedef Tag proto_tag;
3138         static const long proto_arity_c = 9;
3139         typedef mpl::long_<9 > proto_arity;
3140         typedef expr proto_base_expr;
3141         typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
3142         typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
3143         typedef default_domain proto_domain;
3144         typedef default_generator proto_generator;
3145         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
3146         typedef expr proto_derived_expr;
3147         typedef void proto_is_expr_; 
3148         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
3149         typedef void proto_child9;
3150         
3151         
3152         BOOST_FORCEINLINE
3153         expr const &proto_base() const
3154         {
3155             return *this;
3156         }
3157         
3158         
3159         BOOST_FORCEINLINE
3160         expr &proto_base()
3161         {
3162             return *this;
3163         }
3164         
3165         
3166         
3167         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3168         BOOST_FORCEINLINE
3169         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
3170         {
3171             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
3172             return that;
3173         }
3174         
3175         
3176         typedef detail::not_a_valid_type address_of_hack_type_;
3177         
3178         
3179         
3180         
3181         BOOST_FORCEINLINE
3182         proto::expr<
3183             proto::tag::assign
3184           , list2<expr &, expr const &>
3185           , 2
3186         > const
3187         operator =(expr const &a)
3188         {
3189             proto::expr<
3190                 proto::tag::assign
3191               , list2<expr &, expr const &>
3192               , 2
3193             > that = {*this, a};
3194             return that;
3195         }
3196         
3197         
3198         
3199         
3200         template<typename A>
3201         BOOST_FORCEINLINE
3202         proto::expr<
3203             proto::tag::assign
3204           , list2<expr const &, typename result_of::as_child<A>::type>
3205           , 2
3206         > const
3207         operator =(A &a) const
3208         {
3209             proto::expr<
3210                 proto::tag::assign
3211               , list2<expr const &, typename result_of::as_child<A>::type>
3212               , 2
3213             > that = {*this, proto::as_child(a)};
3214             return that;
3215         }
3216         
3217         
3218         template<typename A>
3219         BOOST_FORCEINLINE
3220         proto::expr<
3221             proto::tag::assign
3222           , list2<expr const &, typename result_of::as_child<A const>::type>
3223           , 2
3224         > const
3225         operator =(A const &a) const
3226         {
3227             proto::expr<
3228                 proto::tag::assign
3229               , list2<expr const &, typename result_of::as_child<A const>::type>
3230               , 2
3231             > that = {*this, proto::as_child(a)};
3232             return that;
3233         }
3234         
3235         
3236         
3237         
3238         template<typename A>
3239         BOOST_FORCEINLINE
3240         proto::expr<
3241             proto::tag::subscript
3242           , list2<expr const &, typename result_of::as_child<A>::type>
3243           , 2
3244         > const
3245         operator [](A &a) const
3246         {
3247             proto::expr<
3248                 proto::tag::subscript
3249               , list2<expr const &, typename result_of::as_child<A>::type>
3250               , 2
3251             > that = {*this, proto::as_child(a)};
3252             return that;
3253         }
3254         
3255         
3256         template<typename A>
3257         BOOST_FORCEINLINE
3258         proto::expr<
3259             proto::tag::subscript
3260           , list2<expr const &, typename result_of::as_child<A const>::type>
3261           , 2
3262         > const
3263         operator [](A const &a) const
3264         {
3265             proto::expr<
3266                 proto::tag::subscript
3267               , list2<expr const &, typename result_of::as_child<A const>::type>
3268               , 2
3269             > that = {*this, proto::as_child(a)};
3270             return that;
3271         }
3272         
3273         
3274         template<typename Sig>
3275         struct result
3276         {
3277             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
3278         };
3279         
3280         
3281         
3282         BOOST_FORCEINLINE
3283         proto::expr<proto::tag::function, list1<expr const &>, 1> const
3284         operator ()() const
3285         {
3286             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
3287             return that;
3288         }
3289         
3290         
3291         template<typename A0>
3292         BOOST_FORCEINLINE
3293         typename result_of::funop1<
3294             expr const
3295           , default_domain , const A0
3296         >::type const
3297         operator ()(A0 const &a0) const
3298         {
3299             return result_of::funop1<
3300                 expr const
3301               , default_domain , const A0
3302             >::call(*this , a0);
3303         }
3304         
3305         
3306         template<typename A0 , typename A1>
3307         BOOST_FORCEINLINE
3308         typename result_of::funop2<
3309             expr const
3310           , default_domain , const A0 , const A1
3311         >::type const
3312         operator ()(A0 const &a0 , A1 const &a1) const
3313         {
3314             return result_of::funop2<
3315                 expr const
3316               , default_domain , const A0 , const A1
3317             >::call(*this , a0 , a1);
3318         }
3319         
3320         
3321         template<typename A0 , typename A1 , typename A2>
3322         BOOST_FORCEINLINE
3323         typename result_of::funop3<
3324             expr const
3325           , default_domain , const A0 , const A1 , const A2
3326         >::type const
3327         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3328         {
3329             return result_of::funop3<
3330                 expr const
3331               , default_domain , const A0 , const A1 , const A2
3332             >::call(*this , a0 , a1 , a2);
3333         }
3334         
3335         
3336         template<typename A0 , typename A1 , typename A2 , typename A3>
3337         BOOST_FORCEINLINE
3338         typename result_of::funop4<
3339             expr const
3340           , default_domain , const A0 , const A1 , const A2 , const A3
3341         >::type const
3342         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3343         {
3344             return result_of::funop4<
3345                 expr const
3346               , default_domain , const A0 , const A1 , const A2 , const A3
3347             >::call(*this , a0 , a1 , a2 , a3);
3348         }
3349         
3350         
3351         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3352         BOOST_FORCEINLINE
3353         typename result_of::funop5<
3354             expr const
3355           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3356         >::type const
3357         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3358         {
3359             return result_of::funop5<
3360                 expr const
3361               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3362             >::call(*this , a0 , a1 , a2 , a3 , a4);
3363         }
3364         
3365         
3366         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3367         BOOST_FORCEINLINE
3368         typename result_of::funop6<
3369             expr const
3370           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3371         >::type const
3372         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3373         {
3374             return result_of::funop6<
3375                 expr const
3376               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3377             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3378         }
3379         
3380         
3381         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3382         BOOST_FORCEINLINE
3383         typename result_of::funop7<
3384             expr const
3385           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3386         >::type const
3387         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3388         {
3389             return result_of::funop7<
3390                 expr const
3391               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3392             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3393         }
3394         
3395         
3396         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3397         BOOST_FORCEINLINE
3398         typename result_of::funop8<
3399             expr const
3400           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3401         >::type const
3402         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3403         {
3404             return result_of::funop8<
3405                 expr const
3406               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3407             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3408         }
3409         
3410         
3411         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3412         BOOST_FORCEINLINE
3413         typename result_of::funop9<
3414             expr const
3415           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3416         >::type const
3417         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3418         {
3419             return result_of::funop9<
3420                 expr const
3421               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3422             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3423         }
3424     };
3425     
3426     
3427     
3428     
3429     
3430     
3431     
3432     
3433     
3434     
3435     
3436     
3437     
3438     
3439     
3440     
3441     
3442     
3443     
3444     
3445     
3446     
3447     
3448     
3449     
3450     
3451     
3452     template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
3453     struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
3454     {
3455         typedef Tag proto_tag;
3456         static const long proto_arity_c = 10;
3457         typedef mpl::long_<10 > proto_arity;
3458         typedef expr proto_base_expr;
3459         typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
3460         typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
3461         typedef default_domain proto_domain;
3462         typedef default_generator proto_generator;
3463         typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
3464         typedef expr proto_derived_expr;
3465         typedef void proto_is_expr_; 
3466         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
3467         
3468         
3469         
3470         BOOST_FORCEINLINE
3471         expr const &proto_base() const
3472         {
3473             return *this;
3474         }
3475         
3476         
3477         BOOST_FORCEINLINE
3478         expr &proto_base()
3479         {
3480             return *this;
3481         }
3482         
3483         
3484         
3485         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
3486         BOOST_FORCEINLINE
3487         static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
3488         {
3489             expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
3490             return that;
3491         }
3492         
3493         
3494         typedef detail::not_a_valid_type address_of_hack_type_;
3495         
3496         
3497         
3498         
3499         BOOST_FORCEINLINE
3500         proto::expr<
3501             proto::tag::assign
3502           , list2<expr &, expr const &>
3503           , 2
3504         > const
3505         operator =(expr const &a)
3506         {
3507             proto::expr<
3508                 proto::tag::assign
3509               , list2<expr &, expr const &>
3510               , 2
3511             > that = {*this, a};
3512             return that;
3513         }
3514         
3515         
3516         
3517         
3518         template<typename A>
3519         BOOST_FORCEINLINE
3520         proto::expr<
3521             proto::tag::assign
3522           , list2<expr const &, typename result_of::as_child<A>::type>
3523           , 2
3524         > const
3525         operator =(A &a) const
3526         {
3527             proto::expr<
3528                 proto::tag::assign
3529               , list2<expr const &, typename result_of::as_child<A>::type>
3530               , 2
3531             > that = {*this, proto::as_child(a)};
3532             return that;
3533         }
3534         
3535         
3536         template<typename A>
3537         BOOST_FORCEINLINE
3538         proto::expr<
3539             proto::tag::assign
3540           , list2<expr const &, typename result_of::as_child<A const>::type>
3541           , 2
3542         > const
3543         operator =(A const &a) const
3544         {
3545             proto::expr<
3546                 proto::tag::assign
3547               , list2<expr const &, typename result_of::as_child<A const>::type>
3548               , 2
3549             > that = {*this, proto::as_child(a)};
3550             return that;
3551         }
3552         
3553         
3554         
3555         
3556         template<typename A>
3557         BOOST_FORCEINLINE
3558         proto::expr<
3559             proto::tag::subscript
3560           , list2<expr const &, typename result_of::as_child<A>::type>
3561           , 2
3562         > const
3563         operator [](A &a) const
3564         {
3565             proto::expr<
3566                 proto::tag::subscript
3567               , list2<expr const &, typename result_of::as_child<A>::type>
3568               , 2
3569             > that = {*this, proto::as_child(a)};
3570             return that;
3571         }
3572         
3573         
3574         template<typename A>
3575         BOOST_FORCEINLINE
3576         proto::expr<
3577             proto::tag::subscript
3578           , list2<expr const &, typename result_of::as_child<A const>::type>
3579           , 2
3580         > const
3581         operator [](A const &a) const
3582         {
3583             proto::expr<
3584                 proto::tag::subscript
3585               , list2<expr const &, typename result_of::as_child<A const>::type>
3586               , 2
3587             > that = {*this, proto::as_child(a)};
3588             return that;
3589         }
3590         
3591         
3592         template<typename Sig>
3593         struct result
3594         {
3595             typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
3596         };
3597         
3598         
3599         
3600         BOOST_FORCEINLINE
3601         proto::expr<proto::tag::function, list1<expr const &>, 1> const
3602         operator ()() const
3603         {
3604             proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
3605             return that;
3606         }
3607         
3608         
3609         template<typename A0>
3610         BOOST_FORCEINLINE
3611         typename result_of::funop1<
3612             expr const
3613           , default_domain , const A0
3614         >::type const
3615         operator ()(A0 const &a0) const
3616         {
3617             return result_of::funop1<
3618                 expr const
3619               , default_domain , const A0
3620             >::call(*this , a0);
3621         }
3622         
3623         
3624         template<typename A0 , typename A1>
3625         BOOST_FORCEINLINE
3626         typename result_of::funop2<
3627             expr const
3628           , default_domain , const A0 , const A1
3629         >::type const
3630         operator ()(A0 const &a0 , A1 const &a1) const
3631         {
3632             return result_of::funop2<
3633                 expr const
3634               , default_domain , const A0 , const A1
3635             >::call(*this , a0 , a1);
3636         }
3637         
3638         
3639         template<typename A0 , typename A1 , typename A2>
3640         BOOST_FORCEINLINE
3641         typename result_of::funop3<
3642             expr const
3643           , default_domain , const A0 , const A1 , const A2
3644         >::type const
3645         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
3646         {
3647             return result_of::funop3<
3648                 expr const
3649               , default_domain , const A0 , const A1 , const A2
3650             >::call(*this , a0 , a1 , a2);
3651         }
3652         
3653         
3654         template<typename A0 , typename A1 , typename A2 , typename A3>
3655         BOOST_FORCEINLINE
3656         typename result_of::funop4<
3657             expr const
3658           , default_domain , const A0 , const A1 , const A2 , const A3
3659         >::type const
3660         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
3661         {
3662             return result_of::funop4<
3663                 expr const
3664               , default_domain , const A0 , const A1 , const A2 , const A3
3665             >::call(*this , a0 , a1 , a2 , a3);
3666         }
3667         
3668         
3669         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
3670         BOOST_FORCEINLINE
3671         typename result_of::funop5<
3672             expr const
3673           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3674         >::type const
3675         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
3676         {
3677             return result_of::funop5<
3678                 expr const
3679               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
3680             >::call(*this , a0 , a1 , a2 , a3 , a4);
3681         }
3682         
3683         
3684         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
3685         BOOST_FORCEINLINE
3686         typename result_of::funop6<
3687             expr const
3688           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3689         >::type const
3690         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
3691         {
3692             return result_of::funop6<
3693                 expr const
3694               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
3695             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
3696         }
3697         
3698         
3699         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
3700         BOOST_FORCEINLINE
3701         typename result_of::funop7<
3702             expr const
3703           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3704         >::type const
3705         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
3706         {
3707             return result_of::funop7<
3708                 expr const
3709               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
3710             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
3711         }
3712         
3713         
3714         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
3715         BOOST_FORCEINLINE
3716         typename result_of::funop8<
3717             expr const
3718           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3719         >::type const
3720         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
3721         {
3722             return result_of::funop8<
3723                 expr const
3724               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
3725             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
3726         }
3727         
3728         
3729         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
3730         BOOST_FORCEINLINE
3731         typename result_of::funop9<
3732             expr const
3733           , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3734         >::type const
3735         operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
3736         {
3737             return result_of::funop9<
3738                 expr const
3739               , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
3740             >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
3741         }
3742     };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!