# valarray_after.h

Go to the documentation of this file.

    00001 // The template and inlines for the -*- C++ -*- internal _Meta class.
    00002
    00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
    00004 // 2009  Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 3, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // Under Section 7 of GPL version 3, you are granted additional
    00018 // permissions described in the GCC Runtime Library Exception, version
    00019 // 3.1, as published by the Free Software Foundation.
    00020
    00021 // You should have received a copy of the GNU General Public License and
    00022 // a copy of the GCC Runtime Library Exception along with this program;
    00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    00024 // <http://www.gnu.org/licenses/>.
    00025
    00026 /** @file valarray_after.h
    00027  *  This is an internal header file, included by other library headers.
    00028  *  You should not attempt to use it directly.
    00029  */
    00030
    00031 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
    00032
    00033 #ifndef _VALARRAY_AFTER_H
    00034 #define _VALARRAY_AFTER_H 1
    00035
    00036 #pragma GCC system_header
    00037
    00038 _GLIBCXX_BEGIN_NAMESPACE(std)
    00039
    00040   //
    00041   // gslice_array closure.
    00042   //
    00043   template<class _Dom>
    00044     class _GBase
    00045     {
    00046     public:
    00047       typedef typename _Dom::value_type value_type;
    00048
    00049       _GBase (const _Dom& __e, const valarray<size_t>& __i)
    00050       : _M_expr (__e), _M_index(__i) {}
    00051
    00052       value_type
    00053       operator[] (size_t __i) const
    00054       { return _M_expr[_M_index[__i]]; }
    00055
    00056       size_t
    00057       size () const
    00058       { return _M_index.size(); }
    00059
    00060     private:
    00061       const _Dom&         _M_expr;
    00062       const valarray<size_t>& _M_index;
    00063     };
    00064
    00065   template<typename _Tp>
    00066     class _GBase<_Array<_Tp> >
    00067     {
    00068     public:
    00069       typedef _Tp value_type;
    00070
    00071       _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
    00072       : _M_array (__a), _M_index(__i) {}
    00073
    00074       value_type
    00075       operator[] (size_t __i) const
    00076       { return _M_array._M_data[_M_index[__i]]; }
    00077
    00078       size_t
    00079       size () const
    00080       { return _M_index.size(); }
    00081
    00082     private:
    00083       const _Array<_Tp>       _M_array;
    00084       const valarray<size_t>& _M_index;
    00085     };
    00086
    00087   template<class _Dom>
    00088     struct _GClos<_Expr, _Dom>
    00089     : _GBase<_Dom>
    00090     {
    00091       typedef _GBase<_Dom> _Base;
    00092       typedef typename _Base::value_type value_type;
    00093
    00094       _GClos (const _Dom& __e, const valarray<size_t>& __i)
    00095       : _Base (__e, __i) {}
    00096     };
    00097
    00098   template<typename _Tp>
    00099     struct _GClos<_ValArray, _Tp>
    00100     : _GBase<_Array<_Tp> >
    00101     {
    00102       typedef _GBase<_Array<_Tp> > _Base;
    00103       typedef typename _Base::value_type value_type;
    00104
    00105       _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
    00106       : _Base (__a, __i) {}
    00107     };
    00108
    00109   //
    00110   // indirect_array closure
    00111   //
    00112   template<class _Dom>
    00113     class _IBase
    00114     {
    00115     public:
    00116       typedef typename _Dom::value_type value_type;
    00117
    00118       _IBase (const _Dom& __e, const valarray<size_t>& __i)
    00119       : _M_expr (__e), _M_index (__i) {}
    00120
    00121       value_type
    00122       operator[] (size_t __i) const
    00123       { return _M_expr[_M_index[__i]]; }
    00124
    00125       size_t
    00126       size() const
    00127       { return _M_index.size(); }
    00128
    00129     private:
    00130       const _Dom&         _M_expr;
    00131       const valarray<size_t>& _M_index;
    00132     };
    00133
    00134   template<class _Dom>
    00135     struct _IClos<_Expr, _Dom>
    00136     : _IBase<_Dom>
    00137     {
    00138       typedef _IBase<_Dom> _Base;
    00139       typedef typename _Base::value_type value_type;
    00140
    00141       _IClos (const _Dom& __e, const valarray<size_t>& __i)
    00142       : _Base (__e, __i) {}
    00143     };
    00144
    00145   template<typename _Tp>
    00146     struct _IClos<_ValArray, _Tp>
    00147     : _IBase<valarray<_Tp> >
    00148     {
    00149       typedef _IBase<valarray<_Tp> > _Base;
    00150       typedef _Tp value_type;
    00151
    00152       _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
    00153       : _Base (__a, __i) {}
    00154     };
    00155
    00156   //
    00157   // class _Expr
    00158   //
    00159   template<class _Clos, typename _Tp>
    00160     class _Expr
    00161     {
    00162     public:
    00163       typedef _Tp value_type;
    00164
    00165       _Expr(const _Clos&);
    00166
    00167       const _Clos& operator()() const;
    00168
    00169       value_type operator[](size_t) const;
    00170       valarray<value_type> operator[](slice) const;
    00171       valarray<value_type> operator[](const gslice&) const;
    00172       valarray<value_type> operator[](const valarray<bool>&) const;
    00173       valarray<value_type> operator[](const valarray<size_t>&) const;
    00174
    00175       _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
    00176       operator+() const;
    00177
    00178       _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
    00179       operator-() const;
    00180
    00181       _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
    00182       operator~() const;
    00183
    00184       _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
    00185       operator!() const;
    00186
    00187       size_t size() const;
    00188       value_type sum() const;
    00189
    00190       valarray<value_type> shift(int) const;
    00191       valarray<value_type> cshift(int) const;
    00192
    00193       value_type min() const;
    00194       value_type max() const;
    00195
    00196       valarray<value_type> apply(value_type (*)(const value_type&)) const;
    00197       valarray<value_type> apply(value_type (*)(value_type)) const;
    00198
    00199     private:
    00200       const _Clos _M_closure;
    00201     };
    00202
    00203   template<class _Clos, typename _Tp>
    00204     inline
    00205     _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
    00206
    00207   template<class _Clos, typename _Tp>
    00208     inline const _Clos&
    00209     _Expr<_Clos, _Tp>::operator()() const
    00210     { return _M_closure; }
    00211
    00212   template<class _Clos, typename _Tp>
    00213     inline _Tp
    00214     _Expr<_Clos, _Tp>::operator[](size_t __i) const
    00215     { return _M_closure[__i]; }
    00216
    00217   template<class _Clos, typename _Tp>
    00218     inline valarray<_Tp>
    00219     _Expr<_Clos, _Tp>::operator[](slice __s) const
    00220     {
    00221       valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
    00222       return __v;
    00223     }
    00224
    00225   template<class _Clos, typename _Tp>
    00226     inline valarray<_Tp>
    00227     _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
    00228     {
    00229       valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
    00230       return __v;
    00231     }
    00232
    00233   template<class _Clos, typename _Tp>
    00234     inline valarray<_Tp>
    00235     _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
    00236     {
    00237       valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
    00238       return __v;
    00239     }
    00240
    00241   template<class _Clos, typename _Tp>
    00242     inline valarray<_Tp>
    00243     _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
    00244     {
    00245       valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
    00246       return __v;
    00247     }
    00248
    00249   template<class _Clos, typename _Tp>
    00250     inline size_t
    00251     _Expr<_Clos, _Tp>::size() const
    00252     { return _M_closure.size(); }
    00253
    00254   template<class _Clos, typename _Tp>
    00255     inline valarray<_Tp>
    00256     _Expr<_Clos, _Tp>::shift(int __n) const
    00257     {
    00258       valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
    00259       return __v;
    00260     }
    00261
    00262   template<class _Clos, typename _Tp>
    00263     inline valarray<_Tp>
    00264     _Expr<_Clos, _Tp>::cshift(int __n) const
    00265     {
    00266       valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
    00267       return __v;
    00268     }
    00269
    00270   template<class _Clos, typename _Tp>
    00271     inline valarray<_Tp>
    00272     _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
    00273     {
    00274       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
    00275       return __v;
    00276     }
    00277
    00278   template<class _Clos, typename _Tp>
    00279     inline valarray<_Tp>
    00280     _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
    00281     {
    00282       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
    00283       return __v;
    00284     }
    00285
    00286   // XXX: replace this with a more robust summation algorithm.
    00287   template<class _Clos, typename _Tp>
    00288     inline _Tp
    00289     _Expr<_Clos, _Tp>::sum() const
    00290     {
    00291       size_t __n = _M_closure.size();
    00292       if (__n == 0)
    00293     return _Tp();
    00294       else
    00295     {
    00296       _Tp __s = _M_closure[--__n];
    00297       while (__n != 0)
    00298         __s += _M_closure[--__n];
    00299       return __s;
    00300         }
    00301     }
    00302
    00303   template<class _Clos, typename _Tp>
    00304     inline _Tp
    00305     _Expr<_Clos, _Tp>::min() const
    00306     { return __valarray_min(_M_closure); }
    00307
    00308   template<class _Clos, typename _Tp>
    00309     inline _Tp
    00310     _Expr<_Clos, _Tp>::max() const
    00311     { return __valarray_max(_M_closure); }
    00312
    00313   template<class _Dom, typename _Tp>
    00314     inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
    00315     _Expr<_Dom, _Tp>::operator!() const
    00316     {
    00317       typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
    00318       return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));
    00319     }
    00320
    00321 #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name)                           \
    00322   template<class _Dom, typename _Tp>                                      \
    00323     inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp>                   \
    00324     _Expr<_Dom, _Tp>::operator _Op() const                                \
    00325     {                                                                     \
    00326       typedef _UnClos<_Name, std::_Expr, _Dom> _Closure;                  \
    00327       return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));            \
    00328     }
    00329
    00330     _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
    00331     _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
    00332     _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
    00333
    00334 #undef _DEFINE_EXPR_UNARY_OPERATOR
    00335
    00336 #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name)                        \
    00337   template<class _Dom1, class _Dom2>                    \
    00338     inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>,           \
    00339            typename __fun<_Name, typename _Dom1::value_type>::result_type> \
    00340     operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v,   \
    00341              const _Expr<_Dom2, typename _Dom2::value_type>& __w)   \
    00342     {                                                                   \
    00343       typedef typename _Dom1::value_type _Arg;                          \
    00344       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
    00345       typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure;     \
    00346       return _Expr<_Closure, _Value>(_Closure(__v(), __w()));           \
    00347     }                                                                   \
    00348                                                                         \
    00349   template<class _Dom>                                                  \
    00350     inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom,                \
    00351                           typename _Dom::value_type>,                   \
    00352              typename __fun<_Name, typename _Dom::value_type>::result_type> \
    00353     operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v,     \
    00354                  const typename _Dom::value_type& __t)                  \
    00355     {                                                                   \
    00356       typedef typename _Dom::value_type _Arg;                           \
    00357       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
    00358       typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure;   \
    00359       return _Expr<_Closure, _Value>(_Closure(__v(), __t));             \
    00360     }                                                                   \
    00361                                                                         \
    00362   template<class _Dom>                                                  \
    00363     inline _Expr<_BinClos<_Name, _Constant, _Expr,                      \
    00364                           typename _Dom::value_type, _Dom>,             \
    00365              typename __fun<_Name, typename _Dom::value_type>::result_type> \
    00366     operator _Op(const typename _Dom::value_type& __t,                  \
    00367                  const _Expr<_Dom, typename _Dom::value_type>& __v)     \
    00368     {                                                                   \
    00369       typedef typename _Dom::value_type _Arg;                           \
    00370       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
    00371       typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure;   \
    00372       return _Expr<_Closure, _Value>(_Closure(__t, __v()));             \
    00373     }                                                                   \
    00374                                                                         \
    00375   template<class _Dom>                                                  \
    00376     inline _Expr<_BinClos<_Name, _Expr, _ValArray,                      \
    00377                           _Dom, typename _Dom::value_type>,             \
    00378              typename __fun<_Name, typename _Dom::value_type>::result_type> \
    00379     operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e,      \
    00380                  const valarray<typename _Dom::value_type>& __v)        \
    00381     {                                                                   \
    00382       typedef typename _Dom::value_type _Arg;                           \
    00383       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
    00384       typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure;   \
    00385       return _Expr<_Closure, _Value>(_Closure(__e(), __v));             \
    00386     }                                                                   \
    00387                                                                         \
    00388   template<class _Dom>                                                  \
    00389     inline _Expr<_BinClos<_Name, _ValArray, _Expr,                      \
    00390                  typename _Dom::value_type, _Dom>,                      \
    00391              typename __fun<_Name, typename _Dom::value_type>::result_type> \
    00392     operator _Op(const valarray<typename _Dom::value_type>& __v,        \
    00393                  const _Expr<_Dom, typename _Dom::value_type>& __e)     \
    00394     {                                                                   \
    00395       typedef typename _Dom::value_type _Tp;                            \
    00396       typedef typename __fun<_Name, _Tp>::result_type _Value;           \
    00397       typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure;    \
    00398       return _Expr<_Closure, _Value>(_Closure(__v, __e ()));            \
    00399     }
    00400
    00401     _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
    00402     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
    00403     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
    00404     _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
    00405     _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
    00406     _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
    00407     _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
    00408     _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
    00409     _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
    00410     _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
    00411     _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
    00412     _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
    00413     _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
    00414     _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
    00415     _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
    00416     _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
    00417     _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
    00418     _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
    00419
    00420 #undef _DEFINE_EXPR_BINARY_OPERATOR
    00421
    00422 #define _DEFINE_EXPR_UNARY_FUNCTION(_Name)                               \
    00423   template<class _Dom>                                                   \
    00424     inline _Expr<_UnClos<__##_Name, _Expr, _Dom>,                        \
    00425                  typename _Dom::value_type>                              \
    00426     _Name(const _Expr<_Dom, typename _Dom::value_type>& __e)             \
    00427     {                                                                    \
    00428       typedef typename _Dom::value_type _Tp;                             \
    00429       typedef _UnClos<__##_Name, _Expr, _Dom> _Closure;                  \
    00430       return _Expr<_Closure, _Tp>(_Closure(__e()));                      \
    00431     }                                                                    \
    00432                                                                          \
    00433   template<typename _Tp>                                                 \
    00434     inline _Expr<_UnClos<__##_Name, _ValArray, _Tp>, _Tp>                \
    00435     _Name(const valarray<_Tp>& __v)                                      \
    00436     {                                                                    \
    00437       typedef _UnClos<__##_Name, _ValArray, _Tp> _Closure;               \
    00438       return _Expr<_Closure, _Tp>(_Closure(__v));                        \
    00439     }
    00440
    00441     _DEFINE_EXPR_UNARY_FUNCTION(abs)
    00442     _DEFINE_EXPR_UNARY_FUNCTION(cos)
    00443     _DEFINE_EXPR_UNARY_FUNCTION(acos)
    00444     _DEFINE_EXPR_UNARY_FUNCTION(cosh)
    00445     _DEFINE_EXPR_UNARY_FUNCTION(sin)
    00446     _DEFINE_EXPR_UNARY_FUNCTION(asin)
    00447     _DEFINE_EXPR_UNARY_FUNCTION(sinh)
    00448     _DEFINE_EXPR_UNARY_FUNCTION(tan)
    00449     _DEFINE_EXPR_UNARY_FUNCTION(tanh)
    00450     _DEFINE_EXPR_UNARY_FUNCTION(atan)
    00451     _DEFINE_EXPR_UNARY_FUNCTION(exp)
    00452     _DEFINE_EXPR_UNARY_FUNCTION(log)
    00453     _DEFINE_EXPR_UNARY_FUNCTION(log10)
    00454     _DEFINE_EXPR_UNARY_FUNCTION(sqrt)
    00455
    00456 #undef _DEFINE_EXPR_UNARY_FUNCTION
    00457
    00458 #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun)                             \
    00459   template<class _Dom1, class _Dom2>                                   \
    00460     inline _Expr<_BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2>,       \
    00461          typename _Dom1::value_type>                           \
    00462     _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1,         \
    00463       const _Expr<_Dom2, typename _Dom2::value_type>& __e2)        \
    00464     {                                                                  \
    00465       typedef typename _Dom1::value_type _Tp;                          \
    00466       typedef _BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
    00467       return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2()));           \
    00468     }                                                                  \
    00469                                                                        \
    00470   template<class _Dom>                                                 \
    00471     inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom,            \
    00472               typename _Dom::value_type>,                  \
    00473          typename _Dom::value_type>                            \
    00474     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
    00475      const valarray<typename _Dom::value_type>& __v)               \
    00476     {                                                                  \
    00477       typedef typename _Dom::value_type _Tp;                           \
    00478       typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure; \
    00479       return _Expr<_Closure, _Tp>(_Closure(__e(), __v));               \
    00480     }                                                                  \
    00481                                                                        \
    00482   template<class _Dom>                                                 \
    00483     inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr,                  \
    00484               typename _Dom::value_type, _Dom>,            \
    00485          typename _Dom::value_type>                            \
    00486     _Fun(const valarray<typename _Dom::valarray>& __v,                 \
    00487      const _Expr<_Dom, typename _Dom::value_type>& __e)            \
    00488     {                                                                  \
    00489       typedef typename _Dom::value_type _Tp;                           \
    00490       typedef _BinClos<__##_Fun, _ValArray, _Expr, _Tp, _Dom> _Closure; \
    00491       return _Expr<_Closure, _Tp>(_Closure(__v, __e()));               \
    00492     }                                                                  \
    00493                                                                        \
    00494   template<class _Dom>                                                 \
    00495     inline _Expr<_BinClos<__##_Fun, _Expr, _Constant, _Dom,            \
    00496               typename _Dom::value_type>,                  \
    00497          typename _Dom::value_type>                            \
    00498     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
    00499      const typename _Dom::value_type& __t)                         \
    00500     {                                                                  \
    00501       typedef typename _Dom::value_type _Tp;                           \
    00502       typedef _BinClos<__##_Fun, _Expr, _Constant, _Dom, _Tp> _Closure;\
    00503       return _Expr<_Closure, _Tp>(_Closure(__e(), __t));               \
    00504     }                                                                  \
    00505                                                                        \
    00506   template<class _Dom>                                                 \
    00507     inline _Expr<_BinClos<__##_Fun, _Constant, _Expr,                  \
    00508               typename _Dom::value_type, _Dom>,            \
    00509          typename _Dom::value_type>                            \
    00510     _Fun(const typename _Dom::value_type& __t,                         \
    00511      const _Expr<_Dom, typename _Dom::value_type>& __e)            \
    00512     {                                                                  \
    00513       typedef typename _Dom::value_type _Tp;                           \
    00514       typedef _BinClos<__##_Fun, _Constant, _Expr, _Tp, _Dom> _Closure; \
    00515       return _Expr<_Closure, _Tp>(_Closure(__t, __e()));               \
    00516     }                                                                  \
    00517                                                                        \
    00518   template<typename _Tp>                                               \
    00519     inline _Expr<_BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
    00520     _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w)           \
    00521     {                                                                  \
    00522       typedef _BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
    00523       return _Expr<_Closure, _Tp>(_Closure(__v, __w));                 \
    00524     }                                                                  \
    00525                                                                        \
    00526   template<typename _Tp>                                               \
    00527     inline _Expr<_BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
    00528     _Fun(const valarray<_Tp>& __v, const _Tp& __t)                     \
    00529     {                                                                  \
    00530       typedef _BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp> _Closure; \
    00531       return _Expr<_Closure, _Tp>(_Closure(__v, __t));                 \
    00532     }                                                                  \
    00533                                        \
    00534   template<typename _Tp>                                               \
    00535     inline _Expr<_BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
    00536     _Fun(const _Tp& __t, const valarray<_Tp>& __v)                     \
    00537     {                                                                  \
    00538       typedef _BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp> _Closure; \
    00539       return _Expr<_Closure, _Tp>(_Closure(__t, __v));                 \
    00540     }
    00541
    00542 _DEFINE_EXPR_BINARY_FUNCTION(atan2)
    00543 _DEFINE_EXPR_BINARY_FUNCTION(pow)
    00544
    00545 #undef _DEFINE_EXPR_BINARY_FUNCTION
    00546
    00547 _GLIBCXX_END_NAMESPACE
    00548
    00549 #endif /* _CPP_VALARRAY_AFTER_H */