visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/bits/valarray_after.h

557 lines
22KB
Raw Permalink Blame History 

  1. // The template and inlines for the -*- C++ -*- internal _Meta class.

  2. 

  3. // Copyright (C) 1997-2020 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. namespace __detail

  42. {

  43.   //

  44.   // gslice_array closure.

  45.   //

  46.   template<class _Dom>

  47.     class _GBase

  48.     {

  49.     public:

  50.       typedef typename _Dom::value_type value_type;

  51.       

  52.       _GBase (const _Dom& __e, const valarray<size_t>& __i)

  53.       : _M_expr (__e), _M_index(__i) {}

  54.       

  55.       value_type

  56.       operator[] (size_t __i) const

  57.       { return _M_expr[_M_index[__i]]; }

  58.       

  59.       size_t

  60.       size () const

  61.       { return _M_index.size(); }

  62. 

  63.     private:

  64.       typename _ValArrayRef<_Dom>::__type	_M_expr;

  65.       const valarray<size_t>&			_M_index;

  66.     };

  67. 

  68.   template<typename _Tp>

  69.     class _GBase<_Array<_Tp> >

  70.     {

  71.     public:

  72.       typedef _Tp value_type;

  73.       

  74.       _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)

  75.       : _M_array (__a), _M_index(__i) {}

  76.       

  77.       value_type

  78.       operator[] (size_t __i) const

  79.       { return _M_array._M_data[_M_index[__i]]; }

  80.       

  81.       size_t

  82.       size () const

  83.       { return _M_index.size(); }

  84. 

  85.     private:

  86.       const _Array<_Tp>       _M_array;

  87.       const valarray<size_t>& _M_index;

  88.     };

  89. 

  90.   template<class _Dom>

  91.     struct _GClos<_Expr, _Dom>

  92.     : _GBase<_Dom>

  93.     {

  94.       typedef _GBase<_Dom> _Base;

  95.       typedef typename _Base::value_type value_type;

  96.       

  97.       _GClos (const _Dom& __e, const valarray<size_t>& __i)

  98.       : _Base (__e, __i) {}

  99.     };

  100. 

  101.   template<typename _Tp>

  102.     struct _GClos<_ValArray, _Tp>

  103.     : _GBase<_Array<_Tp> >

  104.     {

  105.       typedef _GBase<_Array<_Tp> > _Base;

  106.       typedef typename _Base::value_type value_type;

  107.       

  108.       _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)

  109.       : _Base (__a, __i) {}

  110.     };

  111. 

  112.   //

  113.   // indirect_array closure

  114.   //

  115.   template<class _Dom>

  116.     class _IBase

  117.     {

  118.     public:

  119.       typedef typename _Dom::value_type value_type;

  120. 

  121.       _IBase (const _Dom& __e, const valarray<size_t>& __i)

  122.       : _M_expr (__e), _M_index (__i) {}

  123.       

  124.       value_type

  125.       operator[] (size_t __i) const

  126.       { return _M_expr[_M_index[__i]]; }

  127.       

  128.       size_t

  129.       size() const

  130.       { return _M_index.size(); }

  131. 

  132.     private:

  133.       typename _ValArrayRef<_Dom>::__type	_M_expr;

  134.       const valarray<size_t>&			_M_index;

  135.     };

  136. 

  137.   template<class _Dom>

  138.     struct _IClos<_Expr, _Dom>

  139.     : _IBase<_Dom>

  140.     {

  141.       typedef _IBase<_Dom> _Base;

  142.       typedef typename _Base::value_type value_type;

  143.       

  144.       _IClos (const _Dom& __e, const valarray<size_t>& __i)

  145.       : _Base (__e, __i) {}

  146.     };

  147. 

  148.   template<typename _Tp>

  149.     struct _IClos<_ValArray, _Tp>

  150.     : _IBase<valarray<_Tp> >

  151.     {

  152.       typedef _IBase<valarray<_Tp> > _Base;

  153.       typedef _Tp value_type;

  154.       

  155.       _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)

  156.       : _Base (__a, __i) {}

  157.     };

  158. } // namespace __detail

  159.   

  160.   //

  161.   // class _Expr

  162.   //

  163.   template<class _Clos, typename _Tp>

  164.     class _Expr

  165.     {

  166.     public:

  167.       typedef _Tp value_type;

  168. 

  169.       _Expr(const _Clos&);

  170. 

  171.       const _Clos& operator()() const;

  172. 

  173.       value_type operator[](size_t) const;

  174.       valarray<value_type> operator[](slice) const;

  175.       valarray<value_type> operator[](const gslice&) const;

  176.       valarray<value_type> operator[](const valarray<bool>&) const;

  177.       valarray<value_type> operator[](const valarray<size_t>&) const;

  178. 

  179.       _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>

  180.       operator+() const;

  181. 

  182.       _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>

  183.       operator-() const;

  184. 

  185.       _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>

  186.       operator~() const;

  187. 

  188.       _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>

  189.       operator!() const;

  190. 

  191.       size_t size() const;

  192.       value_type sum() const;

  193. 

  194.       valarray<value_type> shift(int) const;

  195.       valarray<value_type> cshift(int) const;

  196. 

  197.       value_type min() const;

  198.       value_type max() const;

  199. 

  200.       valarray<value_type> apply(value_type (*)(const value_type&)) const;

  201.       valarray<value_type> apply(value_type (*)(value_type)) const;

  202. 

  203.     private:

  204.       const _Clos _M_closure;

  205.     };

  206. 

  207.   template<class _Clos, typename _Tp>

  208.     inline

  209.     _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}

  210. 

  211.   template<class _Clos, typename _Tp>

  212.     inline const _Clos&

  213.     _Expr<_Clos, _Tp>::operator()() const

  214.     { return _M_closure; }

  215. 

  216.   template<class _Clos, typename _Tp>

  217.     inline _Tp

  218.     _Expr<_Clos, _Tp>::operator[](size_t __i) const

  219.     { return _M_closure[__i]; }

  220. 

  221.   template<class _Clos, typename _Tp>

  222.     inline valarray<_Tp>

  223.     _Expr<_Clos, _Tp>::operator[](slice __s) const

  224.     {

  225.       valarray<_Tp> __v = valarray<_Tp>(*this)[__s];

  226.       return __v;

  227.     }

  228. 

  229.   template<class _Clos, typename _Tp>

  230.     inline valarray<_Tp>

  231.     _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const

  232.     {

  233.       valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];

  234.       return __v;

  235.     }

  236. 

  237.   template<class _Clos, typename _Tp>

  238.     inline valarray<_Tp>

  239.     _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const

  240.     {

  241.       valarray<_Tp> __v = valarray<_Tp>(*this)[__m];

  242.       return __v;

  243.     }

  244. 

  245.   template<class _Clos, typename _Tp>

  246.     inline valarray<_Tp>

  247.     _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const

  248.     {

  249.       valarray<_Tp> __v = valarray<_Tp>(*this)[__i];

  250.       return __v;

  251.     }

  252. 

  253.   template<class _Clos, typename _Tp>

  254.     inline size_t

  255.     _Expr<_Clos, _Tp>::size() const

  256.     { return _M_closure.size(); }

  257. 

  258.   template<class _Clos, typename _Tp>

  259.     inline valarray<_Tp>

  260.     _Expr<_Clos, _Tp>::shift(int __n) const

  261.     {

  262.       valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);

  263.       return __v;

  264.     }

  265. 

  266.   template<class _Clos, typename _Tp>

  267.     inline valarray<_Tp>

  268.     _Expr<_Clos, _Tp>::cshift(int __n) const

  269.     {

  270.       valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);

  271.       return __v;

  272.     }

  273. 

  274.   template<class _Clos, typename _Tp>

  275.     inline valarray<_Tp>

  276.     _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const

  277.     {

  278.       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);

  279.       return __v;

  280.     }

  281. 

  282.   template<class _Clos, typename _Tp>

  283.     inline valarray<_Tp>

  284.     _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const

  285.     {

  286.       valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);

  287.       return __v;

  288.     }

  289. 

  290.   // XXX: replace this with a more robust summation algorithm.

  291.   template<class _Clos, typename _Tp>

  292.     inline _Tp

  293.     _Expr<_Clos, _Tp>::sum() const

  294.     {

  295.       size_t __n = _M_closure.size();

  296.       if (__n == 0)

  297. 	return _Tp();

  298.       else

  299. 	{

  300. 	  _Tp __s = _M_closure[--__n];

  301. 	  while (__n != 0)

  302. 	    __s += _M_closure[--__n];

  303. 	  return __s;

  304.         }

  305.     }

  306. 

  307.   template<class _Clos, typename _Tp>

  308.     inline _Tp

  309.     _Expr<_Clos, _Tp>::min() const

  310.     { return __valarray_min(_M_closure); }

  311. 

  312.   template<class _Clos, typename _Tp>

  313.     inline _Tp

  314.     _Expr<_Clos, _Tp>::max() const

  315.     { return __valarray_max(_M_closure); }

  316. 

  317.   template<class _Dom, typename _Tp>

  318.     inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>

  319.     _Expr<_Dom, _Tp>::operator!() const

  320.     {

  321.       typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;

  322.       return _Expr<_Closure, bool>(_Closure(this->_M_closure));

  323.     }

  324. 

  325. #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name)                           \

  326.   template<class _Dom, typename _Tp>                                      \

  327.     inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp>                   \

  328.     _Expr<_Dom, _Tp>::operator _Op() const                                \

  329.     {                                                                     \

  330.       typedef _UnClos<_Name, std::_Expr, _Dom> _Closure;                  \

  331.       return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));            \

  332.     }

  333. 

  334.     _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)

  335.     _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)

  336.     _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)

  337. 

  338. #undef _DEFINE_EXPR_UNARY_OPERATOR

  339. 

  340. #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name)                        \

  341.   template<class _Dom1, class _Dom2>					\

  342.     inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>,           \

  343.            typename __fun<_Name, typename _Dom1::value_type>::result_type> \

  344.     operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v,   \

  345. 	         const _Expr<_Dom2, typename _Dom2::value_type>& __w)   \

  346.     {                                                                   \

  347.       typedef typename _Dom1::value_type _Arg;                          \

  348.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \

  349.       typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure;     \

  350.       return _Expr<_Closure, _Value>(_Closure(__v(), __w()));           \

  351.     }                                                                   \

  352.                                                                         \

  353.   template<class _Dom>                                                  \

  354.     inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom,                \

  355.                           typename _Dom::value_type>,                   \

  356.              typename __fun<_Name, typename _Dom::value_type>::result_type> \

  357.     operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v,     \

  358.                  const typename _Dom::value_type& __t)                  \

  359.     {                                                                   \

  360.       typedef typename _Dom::value_type _Arg;                           \

  361.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \

  362.       typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure;   \

  363.       return _Expr<_Closure, _Value>(_Closure(__v(), __t));             \

  364.     }                                                                   \

  365.                                                                         \

  366.   template<class _Dom>                                                  \

  367.     inline _Expr<_BinClos<_Name, _Constant, _Expr,                      \

  368.                           typename _Dom::value_type, _Dom>,             \

  369.              typename __fun<_Name, typename _Dom::value_type>::result_type> \

  370.     operator _Op(const typename _Dom::value_type& __t,                  \

  371.                  const _Expr<_Dom, typename _Dom::value_type>& __v)     \

  372.     {                                                                   \

  373.       typedef typename _Dom::value_type _Arg;                           \

  374.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \

  375.       typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure;   \

  376.       return _Expr<_Closure, _Value>(_Closure(__t, __v()));             \

  377.     }                                                                   \

  378.                                                                         \

  379.   template<class _Dom>                                                  \

  380.     inline _Expr<_BinClos<_Name, _Expr, _ValArray,                      \

  381.                           _Dom, typename _Dom::value_type>,             \

  382.              typename __fun<_Name, typename _Dom::value_type>::result_type> \

  383.     operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e,      \

  384.                  const valarray<typename _Dom::value_type>& __v)        \

  385.     {                                                                   \

  386.       typedef typename _Dom::value_type _Arg;                           \

  387.       typedef typename __fun<_Name, _Arg>::result_type _Value;          \

  388.       typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure;   \

  389.       return _Expr<_Closure, _Value>(_Closure(__e(), __v));             \

  390.     }                                                                   \

  391.                                                                         \

  392.   template<class _Dom>                                                  \

  393.     inline _Expr<_BinClos<_Name, _ValArray, _Expr,                      \

  394.                  typename _Dom::value_type, _Dom>,                      \

  395.              typename __fun<_Name, typename _Dom::value_type>::result_type> \

  396.     operator _Op(const valarray<typename _Dom::value_type>& __v,        \

  397.                  const _Expr<_Dom, typename _Dom::value_type>& __e)     \

  398.     {                                                                   \

  399.       typedef typename _Dom::value_type _Tp;                            \

  400.       typedef typename __fun<_Name, _Tp>::result_type _Value;           \

  401.       typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure;    \

  402.       return _Expr<_Closure, _Value>(_Closure(__v, __e ()));            \

  403.     }

  404. 

  405.     _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)

  406.     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)

  407.     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)

  408.     _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)

  409.     _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)

  410.     _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)

  411.     _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)

  412.     _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)

  413.     _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)

  414.     _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)

  415.     _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)

  416.     _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)

  417.     _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)

  418.     _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)

  419.     _DEFINE_EXPR_BINARY_OPERATOR(<, __less)

  420.     _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)

  421.     _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)

  422.     _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)

  423. 

  424. #undef _DEFINE_EXPR_BINARY_OPERATOR

  425. 

  426. #define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName)                       \

  427.   template<class _Dom>                                                   \

  428.     inline _Expr<_UnClos<_UName, _Expr, _Dom>,                           \

  429.                  typename _Dom::value_type>                              \

  430.     _Name(const _Expr<_Dom, typename _Dom::value_type>& __e)             \

  431.     {                                                                    \

  432.       typedef typename _Dom::value_type _Tp;                             \

  433.       typedef _UnClos<_UName, _Expr, _Dom> _Closure;                     \

  434.       return _Expr<_Closure, _Tp>(_Closure(__e()));                      \

  435.     }                                                                    \

  436.                                                                          \

  437.   template<typename _Tp>                                                 \

  438.     inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp>                   \

  439.     _Name(const valarray<_Tp>& __v)                                      \

  440.     {                                                                    \

  441.       typedef _UnClos<_UName, _ValArray, _Tp> _Closure;                  \

  442.       return _Expr<_Closure, _Tp>(_Closure(__v));                        \

  443.     }

  444. 

  445.     _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs)

  446.     _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos)

  447.     _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos)

  448.     _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh)

  449.     _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin)

  450.     _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin)

  451.     _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh)

  452.     _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan)

  453.     _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh)

  454.     _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan)

  455.     _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp)

  456.     _DEFINE_EXPR_UNARY_FUNCTION(log, _Log)

  457.     _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10)

  458.     _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt)

  459. 

  460. #undef _DEFINE_EXPR_UNARY_FUNCTION

  461. 

  462. #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun)		       \

  463.   template<class _Dom1, class _Dom2>                                   \

  464.     inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>,          \

  465. 		 typename _Dom1::value_type>                           \

  466.     _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1,         \

  467. 	 const _Expr<_Dom2, typename _Dom2::value_type>& __e2)	       \

  468.     {                                                                  \

  469.       typedef typename _Dom1::value_type _Tp;                          \

  470.       typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure;    \

  471.       return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2()));           \

  472.     }                                                                  \

  473.                                                                        \

  474.   template<class _Dom>                                                 \

  475.     inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom,               \

  476. 			  typename _Dom::value_type>,                  \

  477. 		 typename _Dom::value_type>                            \

  478.     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \

  479. 	 const valarray<typename _Dom::value_type>& __v)               \

  480.     {                                                                  \

  481.       typedef typename _Dom::value_type _Tp;                           \

  482.       typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure;   \

  483.       return _Expr<_Closure, _Tp>(_Closure(__e(), __v));               \

  484.     }                                                                  \

  485.                                                                        \

  486.   template<class _Dom>                                                 \

  487.     inline _Expr<_BinClos<_UFun, _ValArray, _Expr,                     \

  488. 			  typename _Dom::value_type, _Dom>,            \

  489. 		 typename _Dom::value_type>                            \

  490.     _Fun(const valarray<typename _Dom::valarray>& __v,                 \

  491. 	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \

  492.     {                                                                  \

  493.       typedef typename _Dom::value_type _Tp;                           \

  494.       typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure;   \

  495.       return _Expr<_Closure, _Tp>(_Closure(__v, __e()));               \

  496.     }                                                                  \

  497.                                                                        \

  498.   template<class _Dom>                                                 \

  499.     inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom,               \

  500. 			  typename _Dom::value_type>,                  \

  501. 		 typename _Dom::value_type>                            \

  502.     _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \

  503. 	 const typename _Dom::value_type& __t)                         \

  504.     {                                                                  \

  505.       typedef typename _Dom::value_type _Tp;                           \

  506.       typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure;   \

  507.       return _Expr<_Closure, _Tp>(_Closure(__e(), __t));               \

  508.     }                                                                  \

  509.                                                                        \

  510.   template<class _Dom>                                                 \

  511.     inline _Expr<_BinClos<_UFun, _Constant, _Expr,                     \

  512. 			  typename _Dom::value_type, _Dom>,            \

  513. 		 typename _Dom::value_type>                            \

  514.     _Fun(const typename _Dom::value_type& __t,                         \

  515. 	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \

  516.     {                                                                  \

  517.       typedef typename _Dom::value_type _Tp;                           \

  518.       typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure;   \

  519.       return _Expr<_Closure, _Tp>(_Closure(__t, __e()));               \

  520.     }                                                                  \

  521.                                                                        \

  522.   template<typename _Tp>                                               \

  523.     inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \

  524.     _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w)           \

  525.     {                                                                  \

  526.       typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\

  527.       return _Expr<_Closure, _Tp>(_Closure(__v, __w));                 \

  528.     }                                                                  \

  529.                                                                        \

  530.   template<typename _Tp>                                               \

  531.     inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \

  532.     _Fun(const valarray<_Tp>& __v,				       \

  533. 	 const typename valarray<_Tp>::value_type& __t)                \

  534.     {                                                                  \

  535.       typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\

  536.       return _Expr<_Closure, _Tp>(_Closure(__v, __t));                 \

  537.     }                                                                  \

  538. 								       \

  539.   template<typename _Tp>                                               \

  540.     inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \

  541.     _Fun(const typename valarray<_Tp>::value_type& __t,		       \

  542. 	 const valarray<_Tp>& __v)                                     \

  543.     {                                                                  \

  544.       typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\

  545.       return _Expr<_Closure, _Tp>(_Closure(__t, __v));                 \

  546.     }

  547. 

  548. _DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)

  549. _DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)

  550. 

  551. #undef _DEFINE_EXPR_BINARY_FUNCTION

  552. 

  553. _GLIBCXX_END_NAMESPACE_VERSION

  554. } // namespace

  555. 

  556. #endif /* _CPP_VALARRAY_AFTER_H */