Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. // The template and inlines for the -*- C++ -*- internal _Meta class.
  2.  
  3. // Copyright (C) 1997-2013 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /** @file bits/valarray_after.h
  26.  *  This is an internal header file, included by other library headers.
  27.  *  Do not attempt to use it directly. @headername{valarray}
  28.  */
  29.  
  30. // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
  31.  
  32. #ifndef _VALARRAY_AFTER_H
  33. #define _VALARRAY_AFTER_H 1
  34.  
  35. #pragma GCC system_header
  36.  
  37. namespace std _GLIBCXX_VISIBILITY(default)
  38. {
  39. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  40.  
  41.   //
  42.   // gslice_array closure.
  43.   //
  44.   template<class _Dom>
  45.     class _GBase
  46.     {
  47.     public:
  48.       typedef typename _Dom::value_type value_type;
  49.      
  50.       _GBase (const _Dom& __e, const valarray<size_t>& __i)
  51.       : _M_expr (__e), _M_index(__i) {}
  52.      
  53.       value_type
  54.       operator[] (size_t __i) const
  55.       { return _M_expr[_M_index[__i]]; }
  56.      
  57.       size_t
  58.       size () const
  59.       { return _M_index.size(); }
  60.  
  61.     private:
  62.       const _Dom&             _M_expr;
  63.       const valarray<size_t>& _M_index;
  64.     };
  65.  
  66.   template<typename _Tp>
  67.     class _GBase<_Array<_Tp> >
  68.     {
  69.     public:
  70.       typedef _Tp value_type;
  71.      
  72.       _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
  73.       : _M_array (__a), _M_index(__i) {}
  74.      
  75.       value_type
  76.       operator[] (size_t __i) const
  77.       { return _M_array._M_data[_M_index[__i]]; }
  78.      
  79.       size_t
  80.       size () const
  81.       { return _M_index.size(); }
  82.  
  83.     private:
  84.       const _Array<_Tp>       _M_array;
  85.       const valarray<size_t>& _M_index;
  86.     };
  87.  
  88.   template<class _Dom>
  89.     struct _GClos<_Expr, _Dom>
  90.     : _GBase<_Dom>
  91.     {
  92.       typedef _GBase<_Dom> _Base;
  93.       typedef typename _Base::value_type value_type;
  94.      
  95.       _GClos (const _Dom& __e, const valarray<size_t>& __i)
  96.       : _Base (__e, __i) {}
  97.     };
  98.  
  99.   template<typename _Tp>
  100.     struct _GClos<_ValArray, _Tp>
  101.     : _GBase<_Array<_Tp> >
  102.     {
  103.       typedef _GBase<_Array<_Tp> > _Base;
  104.       typedef typename _Base::value_type value_type;
  105.      
  106.       _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
  107.       : _Base (__a, __i) {}
  108.     };
  109.  
  110.   //
  111.   // indirect_array closure
  112.   //
  113.   template<class _Dom>
  114.     class _IBase
  115.     {
  116.     public:
  117.       typedef typename _Dom::value_type value_type;
  118.  
  119.       _IBase (const _Dom& __e, const valarray<size_t>& __i)
  120.       : _M_expr (__e), _M_index (__i) {}
  121.      
  122.       value_type
  123.       operator[] (size_t __i) const
  124.       { return _M_expr[_M_index[__i]]; }
  125.      
  126.       size_t
  127.       size() const
  128.       { return _M_index.size(); }
  129.  
  130.     private:
  131.       const _Dom&             _M_expr;
  132.       const valarray<size_t>& _M_index;
  133.     };
  134.  
  135.   template<class _Dom>
  136.     struct _IClos<_Expr, _Dom>
  137.     : _IBase<_Dom>
  138.     {
  139.       typedef _IBase<_Dom> _Base;
  140.       typedef typename _Base::value_type value_type;
  141.      
  142.       _IClos (const _Dom& __e, const valarray<size_t>& __i)
  143.       : _Base (__e, __i) {}
  144.     };
  145.  
  146.   template<typename _Tp>
  147.     struct _IClos<_ValArray, _Tp>
  148.     : _IBase<valarray<_Tp> >
  149.     {
  150.       typedef _IBase<valarray<_Tp> > _Base;
  151.       typedef _Tp value_type;
  152.      
  153.       _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
  154.       : _Base (__a, __i) {}
  155.     };
  156.  
  157.   //
  158.   // class _Expr
  159.   //
  160.   template<class _Clos, typename _Tp>
  161.     class _Expr
  162.     {
  163.     public:
  164.       typedef _Tp value_type;
  165.  
  166.       _Expr(const _Clos&);
  167.  
  168.       const _Clos& operator()() const;
  169.  
  170.       value_type operator[](size_t) const;
  171.       valarray<value_type> operator[](slice) const;
  172.       valarray<value_type> operator[](const gslice&) const;
  173.       valarray<value_type> operator[](const valarray<bool>&) const;
  174.       valarray<value_type> operator[](const valarray<size_t>&) const;
  175.  
  176.       _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
  177.       operator+() const;
  178.  
  179.       _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
  180.       operator-() const;
  181.  
  182.       _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
  183.       operator~() const;
  184.  
  185.       _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
  186.       operator!() const;
  187.  
  188.       size_t size() const;
  189.       value_type sum() const;
  190.  
  191.       valarray<value_type> shift(int) const;
  192.       valarray<value_type> cshift(int) const;
  193.  
  194.       value_type min() const;
  195.       value_type max() const;
  196.  
  197.       valarray<value_type> apply(value_type (*)(const value_type&)) const;
  198.       valarray<value_type> apply(value_type (*)(value_type)) const;
  199.  
  200.     private:
  201.       const _Clos _M_closure;
  202.     };
  203.  
  204.   template<class _Clos, typename _Tp>
  205.     inline
  206.     _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
  207.  
  208.   template<class _Clos, typename _Tp>
  209.     inline const _Clos&
  210.     _Expr<_Clos, _Tp>::operator()() const
  211.     { return _M_closure; }
  212.  
  213.   template<class _Clos, typename _Tp>
  214.     inline _Tp
  215.     _Expr<_Clos, _Tp>::operator[](size_t __i) const
  216.     { return _M_closure[__i]; }
  217.  
  218.   template<class _Clos, typename _Tp>
  219.     inline valarray<_Tp>
  220.     _Expr<_Clos, _Tp>::operator[](slice __s) const
  221.     {
  222.       valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
  223.       return __v;
  224.     }
  225.  
  226.   template<class _Clos, typename _Tp>
  227.     inline valarray<_Tp>
  228.     _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
  229.     {
  230.       valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
  231.       return __v;
  232.     }
  233.  
  234.   template<class _Clos, typename _Tp>
  235.     inline valarray<_Tp>
  236.     _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
  237.     {
  238.       valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
  239.       return __v;
  240.     }
  241.  
  242.   template<class _Clos, typename _Tp>
  243.     inline valarray<_Tp>
  244.     _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
  245.     {
  246.       valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
  247.       return __v;
  248.     }
  249.  
  250.   template<class _Clos, typename _Tp>
  251.     inline size_t
  252.     _Expr<_Clos, _Tp>::size() const
  253.     { return _M_closure.size(); }
  254.  
  255.   template<class _Clos, typename _Tp>
  256.     inline valarray<_Tp>
  257.     _Expr<_Clos, _Tp>::shift(int __n) const
  258.     {
  259.       valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
  260.       return __v;
  261.     }
  262.  
  263.   template<class _Clos, typename _Tp>
  264.     inline valarray<_Tp>
  265.     _Expr<_Clos, _Tp>::cshift(int __n) const
  266.     {
  267.       valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
  268.       return __v;
  269.     }
  270.  
  271.   template<class _Clos, typename _Tp>
  272.     inline valarray<_Tp>
  273.     _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
  274.     {
  275.       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
  276.       return __v;
  277.     }
  278.  
  279.   template<class _Clos, typename _Tp>
  280.     inline valarray<_Tp>
  281.     _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
  282.     {
  283.       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
  284.       return __v;
  285.     }
  286.  
  287.   // XXX: replace this with a more robust summation algorithm.
  288.   template<class _Clos, typename _Tp>
  289.     inline _Tp
  290.     _Expr<_Clos, _Tp>::sum() const
  291.     {
  292.       size_t __n = _M_closure.size();
  293.       if (__n == 0)
  294.         return _Tp();
  295.       else
  296.         {
  297.           _Tp __s = _M_closure[--__n];
  298.           while (__n != 0)
  299.             __s += _M_closure[--__n];
  300.           return __s;
  301.         }
  302.     }
  303.  
  304.   template<class _Clos, typename _Tp>
  305.     inline _Tp
  306.     _Expr<_Clos, _Tp>::min() const
  307.     { return __valarray_min(_M_closure); }
  308.  
  309.   template<class _Clos, typename _Tp>
  310.     inline _Tp
  311.     _Expr<_Clos, _Tp>::max() const
  312.     { return __valarray_max(_M_closure); }
  313.  
  314.   template<class _Dom, typename _Tp>
  315.     inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
  316.     _Expr<_Dom, _Tp>::operator!() const
  317.     {
  318.       typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
  319.       return _Expr<_Closure, bool>(_Closure(this->_M_closure));
  320.     }
  321.  
  322. #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name)                           \
  323.   template<class _Dom, typename _Tp>                                      \
  324.     inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp>                   \
  325.     _Expr<_Dom, _Tp>::operator _Op() const                                \
  326.     {                                                                     \
  327.       typedef _UnClos<_Name, std::_Expr, _Dom> _Closure;                  \
  328.       return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));            \
  329.     }
  330.  
  331.     _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
  332.     _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
  333.     _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
  334.  
  335. #undef _DEFINE_EXPR_UNARY_OPERATOR
  336.  
  337. #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name)                        \
  338.   template<class _Dom1, class _Dom2>                                    \
  339.     inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>,           \
  340.            typename __fun<_Name, typename _Dom1::value_type>::result_type> \
  341.     operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v,   \
  342.                  const _Expr<_Dom2, typename _Dom2::value_type>& __w)   \
  343.     {                                                                   \
  344.       typedef typename _Dom1::value_type _Arg;                          \
  345.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
  346.       typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure;     \
  347.       return _Expr<_Closure, _Value>(_Closure(__v(), __w()));           \
  348.     }                                                                   \
  349.                                                                         \
  350.   template<class _Dom>                                                  \
  351.     inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom,                \
  352.                           typename _Dom::value_type>,                   \
  353.              typename __fun<_Name, typename _Dom::value_type>::result_type> \
  354.     operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v,     \
  355.                  const typename _Dom::value_type& __t)                  \
  356.     {                                                                   \
  357.       typedef typename _Dom::value_type _Arg;                           \
  358.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
  359.       typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure;   \
  360.       return _Expr<_Closure, _Value>(_Closure(__v(), __t));             \
  361.     }                                                                   \
  362.                                                                         \
  363.   template<class _Dom>                                                  \
  364.     inline _Expr<_BinClos<_Name, _Constant, _Expr,                      \
  365.                           typename _Dom::value_type, _Dom>,             \
  366.              typename __fun<_Name, typename _Dom::value_type>::result_type> \
  367.     operator _Op(const typename _Dom::value_type& __t,                  \
  368.                  const _Expr<_Dom, typename _Dom::value_type>& __v)     \
  369.     {                                                                   \
  370.       typedef typename _Dom::value_type _Arg;                           \
  371.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
  372.       typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure;   \
  373.       return _Expr<_Closure, _Value>(_Closure(__t, __v()));             \
  374.     }                                                                   \
  375.                                                                         \
  376.   template<class _Dom>                                                  \
  377.     inline _Expr<_BinClos<_Name, _Expr, _ValArray,                      \
  378.                           _Dom, typename _Dom::value_type>,             \
  379.              typename __fun<_Name, typename _Dom::value_type>::result_type> \
  380.     operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e,      \
  381.                  const valarray<typename _Dom::value_type>& __v)        \
  382.     {                                                                   \
  383.       typedef typename _Dom::value_type _Arg;                           \
  384.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \
  385.       typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure;   \
  386.       return _Expr<_Closure, _Value>(_Closure(__e(), __v));             \
  387.     }                                                                   \
  388.                                                                         \
  389.   template<class _Dom>                                                  \
  390.     inline _Expr<_BinClos<_Name, _ValArray, _Expr,                      \
  391.                  typename _Dom::value_type, _Dom>,                      \
  392.              typename __fun<_Name, typename _Dom::value_type>::result_type> \
  393.     operator _Op(const valarray<typename _Dom::value_type>& __v,        \
  394.                  const _Expr<_Dom, typename _Dom::value_type>& __e)     \
  395.     {                                                                   \
  396.       typedef typename _Dom::value_type _Tp;                            \
  397.       typedef typename __fun<_Name, _Tp>::result_type _Value;           \
  398.       typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure;    \
  399.       return _Expr<_Closure, _Value>(_Closure(__v, __e ()));            \
  400.     }
  401.  
  402.     _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
  403.     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
  404.     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
  405.     _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
  406.     _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
  407.     _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
  408.     _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
  409.     _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
  410.     _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
  411.     _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
  412.     _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
  413.     _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
  414.     _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
  415.     _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
  416.     _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
  417.     _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
  418.     _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
  419.     _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
  420.  
  421. #undef _DEFINE_EXPR_BINARY_OPERATOR
  422.  
  423. #define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName)                       \
  424.   template<class _Dom>                                                   \
  425.     inline _Expr<_UnClos<_UName, _Expr, _Dom>,                           \
  426.                  typename _Dom::value_type>                              \
  427.     _Name(const _Expr<_Dom, typename _Dom::value_type>& __e)             \
  428.     {                                                                    \
  429.       typedef typename _Dom::value_type _Tp;                             \
  430.       typedef _UnClos<_UName, _Expr, _Dom> _Closure;                     \
  431.       return _Expr<_Closure, _Tp>(_Closure(__e()));                      \
  432.     }                                                                    \
  433.                                                                          \
  434.   template<typename _Tp>                                                 \
  435.     inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp>                   \
  436.     _Name(const valarray<_Tp>& __v)                                      \
  437.     {                                                                    \
  438.       typedef _UnClos<_UName, _ValArray, _Tp> _Closure;                  \
  439.       return _Expr<_Closure, _Tp>(_Closure(__v));                        \
  440.     }
  441.  
  442.     _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs)
  443.     _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos)
  444.     _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos)
  445.     _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh)
  446.     _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin)
  447.     _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin)
  448.     _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh)
  449.     _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan)
  450.     _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh)
  451.     _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan)
  452.     _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp)
  453.     _DEFINE_EXPR_UNARY_FUNCTION(log, _Log)
  454.     _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10)
  455.     _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt)
  456.  
  457. #undef _DEFINE_EXPR_UNARY_FUNCTION
  458.  
  459. #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun)                      \
  460.   template<class _Dom1, class _Dom2>                                   \
  461.     inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>,          \
  462.                  typename _Dom1::value_type>                           \
  463.     _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1,         \
  464.          const _Expr<_Dom2, typename _Dom2::value_type>& __e2)         \
  465.     {                                                                  \
  466.       typedef typename _Dom1::value_type _Tp;                          \
  467.       typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure;    \
  468.       return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2()));           \
  469.     }                                                                  \
  470.                                                                        \
  471.   template<class _Dom>                                                 \
  472.     inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom,               \
  473.                           typename _Dom::value_type>,                  \
  474.                  typename _Dom::value_type>                            \
  475.     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
  476.          const valarray<typename _Dom::value_type>& __v)               \
  477.     {                                                                  \
  478.       typedef typename _Dom::value_type _Tp;                           \
  479.       typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure;   \
  480.       return _Expr<_Closure, _Tp>(_Closure(__e(), __v));               \
  481.     }                                                                  \
  482.                                                                        \
  483.   template<class _Dom>                                                 \
  484.     inline _Expr<_BinClos<_UFun, _ValArray, _Expr,                     \
  485.                           typename _Dom::value_type, _Dom>,            \
  486.                  typename _Dom::value_type>                            \
  487.     _Fun(const valarray<typename _Dom::valarray>& __v,                 \
  488.          const _Expr<_Dom, typename _Dom::value_type>& __e)            \
  489.     {                                                                  \
  490.       typedef typename _Dom::value_type _Tp;                           \
  491.       typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure;   \
  492.       return _Expr<_Closure, _Tp>(_Closure(__v, __e()));               \
  493.     }                                                                  \
  494.                                                                        \
  495.   template<class _Dom>                                                 \
  496.     inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom,               \
  497.                           typename _Dom::value_type>,                  \
  498.                  typename _Dom::value_type>                            \
  499.     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
  500.          const typename _Dom::value_type& __t)                         \
  501.     {                                                                  \
  502.       typedef typename _Dom::value_type _Tp;                           \
  503.       typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure;   \
  504.       return _Expr<_Closure, _Tp>(_Closure(__e(), __t));               \
  505.     }                                                                  \
  506.                                                                        \
  507.   template<class _Dom>                                                 \
  508.     inline _Expr<_BinClos<_UFun, _Constant, _Expr,                     \
  509.                           typename _Dom::value_type, _Dom>,            \
  510.                  typename _Dom::value_type>                            \
  511.     _Fun(const typename _Dom::value_type& __t,                         \
  512.          const _Expr<_Dom, typename _Dom::value_type>& __e)            \
  513.     {                                                                  \
  514.       typedef typename _Dom::value_type _Tp;                           \
  515.       typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure;   \
  516.       return _Expr<_Closure, _Tp>(_Closure(__t, __e()));               \
  517.     }                                                                  \
  518.                                                                        \
  519.   template<typename _Tp>                                               \
  520.     inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
  521.     _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w)           \
  522.     {                                                                  \
  523.       typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
  524.       return _Expr<_Closure, _Tp>(_Closure(__v, __w));                 \
  525.     }                                                                  \
  526.                                                                        \
  527.   template<typename _Tp>                                               \
  528.     inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
  529.     _Fun(const valarray<_Tp>& __v, const _Tp& __t)                     \
  530.     {                                                                  \
  531.       typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
  532.       return _Expr<_Closure, _Tp>(_Closure(__v, __t));                 \
  533.     }                                                                  \
  534.                                                                        \
  535.   template<typename _Tp>                                               \
  536.     inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
  537.     _Fun(const _Tp& __t, const valarray<_Tp>& __v)                     \
  538.     {                                                                  \
  539.       typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
  540.       return _Expr<_Closure, _Tp>(_Closure(__t, __v));                 \
  541.     }
  542.  
  543. _DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)
  544. _DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)
  545.  
  546. #undef _DEFINE_EXPR_BINARY_FUNCTION
  547.  
  548. _GLIBCXX_END_NAMESPACE_VERSION
  549. } // namespace
  550.  
  551. #endif /* _CPP_VALARRAY_AFTER_H */
  552.