[thirdparty/gcc.git] / libstdc++-v3 / include / bits / valarray_after.h

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

// Copyright (C) 1997-2016 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file bits/valarray_after.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{valarray}
 */

// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>

#ifndef _VALARRAY_AFTER_H
#define _VALARRAY_AFTER_H 1

#pragma GCC system_header

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  //
  // gslice_array closure.
  //
  template<class _Dom>
    class _GBase
    {
    public:
      typedef typename _Dom::value_type value_type;
      
      _GBase (const _Dom& __e, const valarray<size_t>& __i)
      : _M_expr (__e), _M_index(__i) {}
      
      value_type
      operator[] (size_t __i) const
      { return _M_expr[_M_index[__i]]; }
      
      size_t
      size () const
      { return _M_index.size(); }

    private:
      const _Dom&	      _M_expr;
      const valarray<size_t>& _M_index;
    };

  template<typename _Tp>
    class _GBase<_Array<_Tp> >
    {
    public:
      typedef _Tp value_type;
      
      _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
      : _M_array (__a), _M_index(__i) {}
      
      value_type
      operator[] (size_t __i) const
      { return _M_array._M_data[_M_index[__i]]; }
      
      size_t
      size () const
      { return _M_index.size(); }

    private:
      const _Array<_Tp>       _M_array;
      const valarray<size_t>& _M_index;
    };

  template<class _Dom>
    struct _GClos<_Expr, _Dom>
    : _GBase<_Dom>
    {
      typedef _GBase<_Dom> _Base;
      typedef typename _Base::value_type value_type;
      
      _GClos (const _Dom& __e, const valarray<size_t>& __i)
      : _Base (__e, __i) {}
    };

  template<typename _Tp>
    struct _GClos<_ValArray, _Tp>
    : _GBase<_Array<_Tp> >
    {
      typedef _GBase<_Array<_Tp> > _Base;
      typedef typename _Base::value_type value_type;
      
      _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
      : _Base (__a, __i) {}
    };

  //
  // indirect_array closure
  //
  template<class _Dom>
    class _IBase
    {
    public:
      typedef typename _Dom::value_type value_type;

      _IBase (const _Dom& __e, const valarray<size_t>& __i)
      : _M_expr (__e), _M_index (__i) {}
      
      value_type
      operator[] (size_t __i) const
      { return _M_expr[_M_index[__i]]; }
      
      size_t
      size() const
      { return _M_index.size(); }

    private:
      const _Dom&	      _M_expr;
      const valarray<size_t>& _M_index;
    };

  template<class _Dom>
    struct _IClos<_Expr, _Dom>
    : _IBase<_Dom>
    {
      typedef _IBase<_Dom> _Base;
      typedef typename _Base::value_type value_type;
      
      _IClos (const _Dom& __e, const valarray<size_t>& __i)
      : _Base (__e, __i) {}
    };

  template<typename _Tp>
    struct _IClos<_ValArray, _Tp>
    : _IBase<valarray<_Tp> >
    {
      typedef _IBase<valarray<_Tp> > _Base;
      typedef _Tp value_type;
      
      _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
      : _Base (__a, __i) {}
    };
  
  //
  // class _Expr
  //
  template<class _Clos, typename _Tp>
    class _Expr
    {
    public:
      typedef _Tp value_type;

      _Expr(const _Clos&);

      const _Clos& operator()() const;

      value_type operator[](size_t) const;
      valarray<value_type> operator[](slice) const;
      valarray<value_type> operator[](const gslice&) const;
      valarray<value_type> operator[](const valarray<bool>&) const;
      valarray<value_type> operator[](const valarray<size_t>&) const;

      _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
      operator+() const;

      _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
      operator-() const;

      _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
      operator~() const;

      _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
      operator!() const;

      size_t size() const;
      value_type sum() const;

      valarray<value_type> shift(int) const;
      valarray<value_type> cshift(int) const;

      value_type min() const;
      value_type max() const;

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

    private:
      const _Clos _M_closure;
    };

  template<class _Clos, typename _Tp>
    inline
    _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}

  template<class _Clos, typename _Tp>
    inline const _Clos&
    _Expr<_Clos, _Tp>::operator()() const
    { return _M_closure; }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::operator[](size_t __i) const
    { return _M_closure[__i]; }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](slice __s) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline size_t
    _Expr<_Clos, _Tp>::size() const
    { return _M_closure.size(); }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::shift(int __n) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::cshift(int __n) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
      return __v;
    }

  template<class _Clos, typename _Tp>
    inline valarray<_Tp>
    _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
    {
      valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
      return __v;
    }

  // XXX: replace this with a more robust summation algorithm.
  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::sum() const
    {
      size_t __n = _M_closure.size();
      if (__n == 0)
	return _Tp();
      else
	{
	  _Tp __s = _M_closure[--__n];
	  while (__n != 0)
	    __s += _M_closure[--__n];
	  return __s;
        }
    }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::min() const
    { return __valarray_min(_M_closure); }

  template<class _Clos, typename _Tp>
    inline _Tp
    _Expr<_Clos, _Tp>::max() const
    { return __valarray_max(_M_closure); }

  template<class _Dom, typename _Tp>
    inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
    _Expr<_Dom, _Tp>::operator!() const
    {
      typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
      return _Expr<_Closure, bool>(_Closure(this->_M_closure));
    }

#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name)                           \
  template<class _Dom, typename _Tp>                                      \
    inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp>                   \
    _Expr<_Dom, _Tp>::operator _Op() const                                \
    {                                                                     \
      typedef _UnClos<_Name, std::_Expr, _Dom> _Closure;                  \
      return _Expr<_Closure, _Tp>(_Closure(this->_M_closure));            \
    }

    _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
    _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
    _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)

#undef _DEFINE_EXPR_UNARY_OPERATOR

#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name)                        \
  template<class _Dom1, class _Dom2>					\
    inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>,           \
           typename __fun<_Name, typename _Dom1::value_type>::result_type> \
    operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v,   \
	         const _Expr<_Dom2, typename _Dom2::value_type>& __w)   \
    {                                                                   \
      typedef typename _Dom1::value_type _Arg;                          \
      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
      typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure;     \
      return _Expr<_Closure, _Value>(_Closure(__v(), __w()));           \
    }                                                                   \
                                                                        \
  template<class _Dom>                                                  \
    inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom,                \
                          typename _Dom::value_type>,                   \
             typename __fun<_Name, typename _Dom::value_type>::result_type> \
    operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v,     \
                 const typename _Dom::value_type& __t)                  \
    {                                                                   \
      typedef typename _Dom::value_type _Arg;                           \
      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
      typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure;   \
      return _Expr<_Closure, _Value>(_Closure(__v(), __t));             \
    }                                                                   \
                                                                        \
  template<class _Dom>                                                  \
    inline _Expr<_BinClos<_Name, _Constant, _Expr,                      \
                          typename _Dom::value_type, _Dom>,             \
             typename __fun<_Name, typename _Dom::value_type>::result_type> \
    operator _Op(const typename _Dom::value_type& __t,                  \
                 const _Expr<_Dom, typename _Dom::value_type>& __v)     \
    {                                                                   \
      typedef typename _Dom::value_type _Arg;                           \
      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
      typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure;   \
      return _Expr<_Closure, _Value>(_Closure(__t, __v()));             \
    }                                                                   \
                                                                        \
  template<class _Dom>                                                  \
    inline _Expr<_BinClos<_Name, _Expr, _ValArray,                      \
                          _Dom, typename _Dom::value_type>,             \
             typename __fun<_Name, typename _Dom::value_type>::result_type> \
    operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e,      \
                 const valarray<typename _Dom::value_type>& __v)        \
    {                                                                   \
      typedef typename _Dom::value_type _Arg;                           \
      typedef typename __fun<_Name, _Arg>::result_type _Value;          \
      typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure;   \
      return _Expr<_Closure, _Value>(_Closure(__e(), __v));             \
    }                                                                   \
                                                                        \
  template<class _Dom>                                                  \
    inline _Expr<_BinClos<_Name, _ValArray, _Expr,                      \
                 typename _Dom::value_type, _Dom>,                      \
             typename __fun<_Name, typename _Dom::value_type>::result_type> \
    operator _Op(const valarray<typename _Dom::value_type>& __v,        \
                 const _Expr<_Dom, typename _Dom::value_type>& __e)     \
    {                                                                   \
      typedef typename _Dom::value_type _Tp;                            \
      typedef typename __fun<_Name, _Tp>::result_type _Value;           \
      typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure;    \
      return _Expr<_Closure, _Value>(_Closure(__v, __e ()));            \
    }

    _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
    _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
    _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
    _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
    _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
    _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
    _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
    _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
    _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
    _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
    _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
    _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
    _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
    _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
    _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
    _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
    _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
    _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)

#undef _DEFINE_EXPR_BINARY_OPERATOR

#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName)                       \
  template<class _Dom>                                                   \
    inline _Expr<_UnClos<_UName, _Expr, _Dom>,                           \
                 typename _Dom::value_type>                              \
    _Name(const _Expr<_Dom, typename _Dom::value_type>& __e)             \
    {                                                                    \
      typedef typename _Dom::value_type _Tp;                             \
      typedef _UnClos<_UName, _Expr, _Dom> _Closure;                     \
      return _Expr<_Closure, _Tp>(_Closure(__e()));                      \
    }                                                                    \
                                                                         \
  template<typename _Tp>                                                 \
    inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp>                   \
    _Name(const valarray<_Tp>& __v)                                      \
    {                                                                    \
      typedef _UnClos<_UName, _ValArray, _Tp> _Closure;                  \
      return _Expr<_Closure, _Tp>(_Closure(__v));                        \
    }

    _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs)
    _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos)
    _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos)
    _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh)
    _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin)
    _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin)
    _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh)
    _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan)
    _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh)
    _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan)
    _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp)
    _DEFINE_EXPR_UNARY_FUNCTION(log, _Log)
    _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10)
    _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt)

#undef _DEFINE_EXPR_UNARY_FUNCTION

#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun)		       \
  template<class _Dom1, class _Dom2>                                   \
    inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>,          \
		 typename _Dom1::value_type>                           \
    _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1,         \
	 const _Expr<_Dom2, typename _Dom2::value_type>& __e2)	       \
    {                                                                  \
      typedef typename _Dom1::value_type _Tp;                          \
      typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure;    \
      return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2()));           \
    }                                                                  \
                                                                       \
  template<class _Dom>                                                 \
    inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom,               \
			  typename _Dom::value_type>,                  \
		 typename _Dom::value_type>                            \
    _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
	 const valarray<typename _Dom::value_type>& __v)               \
    {                                                                  \
      typedef typename _Dom::value_type _Tp;                           \
      typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure;   \
      return _Expr<_Closure, _Tp>(_Closure(__e(), __v));               \
    }                                                                  \
                                                                       \
  template<class _Dom>                                                 \
    inline _Expr<_BinClos<_UFun, _ValArray, _Expr,                     \
			  typename _Dom::value_type, _Dom>,            \
		 typename _Dom::value_type>                            \
    _Fun(const valarray<typename _Dom::valarray>& __v,                 \
	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \
    {                                                                  \
      typedef typename _Dom::value_type _Tp;                           \
      typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure;   \
      return _Expr<_Closure, _Tp>(_Closure(__v, __e()));               \
    }                                                                  \
                                                                       \
  template<class _Dom>                                                 \
    inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom,               \
			  typename _Dom::value_type>,                  \
		 typename _Dom::value_type>                            \
    _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e,            \
	 const typename _Dom::value_type& __t)                         \
    {                                                                  \
      typedef typename _Dom::value_type _Tp;                           \
      typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure;   \
      return _Expr<_Closure, _Tp>(_Closure(__e(), __t));               \
    }                                                                  \
                                                                       \
  template<class _Dom>                                                 \
    inline _Expr<_BinClos<_UFun, _Constant, _Expr,                     \
			  typename _Dom::value_type, _Dom>,            \
		 typename _Dom::value_type>                            \
    _Fun(const typename _Dom::value_type& __t,                         \
	 const _Expr<_Dom, typename _Dom::value_type>& __e)            \
    {                                                                  \
      typedef typename _Dom::value_type _Tp;                           \
      typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure;   \
      return _Expr<_Closure, _Tp>(_Closure(__t, __e()));               \
    }                                                                  \
                                                                       \
  template<typename _Tp>                                               \
    inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
    _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w)           \
    {                                                                  \
      typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
      return _Expr<_Closure, _Tp>(_Closure(__v, __w));                 \
    }                                                                  \
                                                                       \
  template<typename _Tp>                                               \
    inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
    _Fun(const valarray<_Tp>& __v, const _Tp& __t)                     \
    {                                                                  \
      typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
      return _Expr<_Closure, _Tp>(_Closure(__v, __t));                 \
    }                                                                  \
								       \
  template<typename _Tp>                                               \
    inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
    _Fun(const _Tp& __t, const valarray<_Tp>& __v)                     \
    {                                                                  \
      typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
      return _Expr<_Closure, _Tp>(_Closure(__t, __v));                 \
    }

_DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)
_DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)

#undef _DEFINE_EXPR_BINARY_FUNCTION

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif /* _CPP_VALARRAY_AFTER_H */
Commit	Line	Data
1d487aca	1	// The template and inlines for the -- C++ -- internal _Meta class.
1d487aca	2
f1717362	3	// Copyright (C) 1997-2016 Free Software Foundation, Inc.
1d487aca	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
6bc9506f	8	// Free Software Foundation; either version 3, or (at your option)
1d487aca	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
6bc9506f	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.
1d487aca	19
6bc9506f	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/>.
1d487aca	24
5846aeac	25	/** @file bits/valarray_after.h
7a472ef1	26	* This is an internal header file, included by other library headers.
5846aeac	27	* Do not attempt to use it directly. @headername{valarray}
7a472ef1	28	*/
7a472ef1	29
944beac5	30	// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
944beac5	31
5a64d8cf	32	#ifndef _VALARRAY_AFTER_H
5a64d8cf	33	#define _VALARRAY_AFTER_H 1
1d487aca	34
cd319190	35	#pragma GCC system_header
cd319190	36
2948dd21	37	namespace std _GLIBCXX_VISIBILITY(default)
	38	{
	39	_GLIBCXX_BEGIN_NAMESPACE_VERSION
1069247d	40
7558da41	41	//
	42	// gslice_array closure.
	43	//
	44	template<class _Dom>
	45	class _GBase
	46	{
1d487aca	47	public:
7558da41	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(); }
bae9b8af	60
1d487aca	61	private:
7558da41	62	const _Dom& _M_expr;
7558da41	63	const valarray<size_t>& _M_index;
1d487aca	64	};
bae9b8af	65
7558da41	66	template<typename _Tp>
	67	class _GBase<_Array<_Tp> >
	68	{
1d487aca	69	public:
7558da41	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(); }
bae9b8af	82
1d487aca	83	private:
7558da41	84	const _Array<_Tp> _M_array;
7558da41	85	const valarray<size_t>& _M_index;
1d487aca	86	};
1d487aca	87
7558da41	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) {}
1d487aca	97	};
1d487aca	98
7558da41	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) {}
1d487aca	108	};
1d487aca	109
7558da41	110	//
	111	// indirect_array closure
	112	//
	113	template<class _Dom>
	114	class _IBase
	115	{
1d487aca	116	public:
7558da41	117	typedef typename _Dom::value_type value_type;
1d487aca	118
7558da41	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
95e89c24	126	size_t
	127	size() const
	128	{ return _M_index.size(); }
bae9b8af	129
1d487aca	130	private:
7558da41	131	const _Dom& _M_expr;
7558da41	132	const valarray<size_t>& _M_index;
1d487aca	133	};
1d487aca	134
7558da41	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) {}
1d487aca	144	};
1d487aca	145
7558da41	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) {}
1d487aca	155	};
7558da41	156
179fefb5	157	//
179fefb5	158	// class _Expr
bae9b8af	159	//
bae9b8af	160	template<class _Clos, typename _Tp>
179fefb5	161	class _Expr
179fefb5	162	{
1d487aca	163	public:
179fefb5	164	typedef _Tp value_type;
bae9b8af	165
179fefb5	166	_Expr(const _Clos&);
bae9b8af	167
179fefb5	168	const _Clos& operator()() const;
bae9b8af	169
179fefb5	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;
bae9b8af	175
7558da41	176	_Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
7558da41	177	operator+() const;
1d487aca	178
7558da41	179	_Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
7558da41	180	operator-() const;
1d487aca	181
7558da41	182	_Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
7558da41	183	operator~() const;
1d487aca	184
7558da41	185	_Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
7558da41	186	operator!() const;
1d487aca	187
179fefb5	188	size_t size() const;
179fefb5	189	value_type sum() const;
bae9b8af	190
179fefb5	191	valarray<value_type> shift(int) const;
179fefb5	192	valarray<value_type> cshift(int) const;
1d487aca	193
	194	value_type min() const;
	195	value_type max() const;
	196
179fefb5	197	valarray<value_type> apply(value_type (*)(const value_type&)) const;
179fefb5	198	valarray<value_type> apply(value_type (*)(value_type)) const;
bae9b8af	199
1d487aca	200	private:
179fefb5	201	const _Clos _M_closure;
1d487aca	202	};
bae9b8af	203
179fefb5	204	template<class _Clos, typename _Tp>
1d487aca	205	inline
7558da41	206	_Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
bae9b8af	207
179fefb5	208	template<class _Clos, typename _Tp>
1d487aca	209	inline const _Clos&
7558da41	210	_Expr<_Clos, _Tp>::operator()() const
1d487aca	211	{ return _M_closure; }
1d487aca	212
179fefb5	213	template<class _Clos, typename _Tp>
1d487aca	214	inline _Tp
7558da41	215	_Expr<_Clos, _Tp>::operator[](size_t __i) const
1d487aca	216	{ return _M_closure[__i]; }
1d487aca	217
179fefb5	218	template<class _Clos, typename _Tp>
1d487aca	219	inline valarray<_Tp>
7558da41	220	_Expr<_Clos, _Tp>::operator[](slice __s) const
0911e38f	221	{
	222	valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
	223	return __v;
	224	}
bae9b8af	225
179fefb5	226	template<class _Clos, typename _Tp>
1d487aca	227	inline valarray<_Tp>
7558da41	228	_Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
0911e38f	229	{
	230	valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
	231	return __v;
	232	}
bae9b8af	233
179fefb5	234	template<class _Clos, typename _Tp>
1d487aca	235	inline valarray<_Tp>
7558da41	236	_Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
0911e38f	237	{
	238	valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
	239	return __v;
	240	}
bae9b8af	241
179fefb5	242	template<class _Clos, typename _Tp>
1d487aca	243	inline valarray<_Tp>
7558da41	244	_Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
0911e38f	245	{
	246	valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
	247	return __v;
	248	}
bae9b8af	249
179fefb5	250	template<class _Clos, typename _Tp>
1d487aca	251	inline size_t
7558da41	252	_Expr<_Clos, _Tp>::size() const
0911e38f	253	{ return _M_closure.size(); }
1d487aca	254
1d487aca	255	template<class _Clos, typename _Tp>
179fefb5	256	inline valarray<_Tp>
179fefb5	257	_Expr<_Clos, _Tp>::shift(int __n) const
0911e38f	258	{
	259	valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
	260	return __v;
	261	}
1d487aca	262
1d487aca	263	template<class _Clos, typename _Tp>
179fefb5	264	inline valarray<_Tp>
179fefb5	265	_Expr<_Clos, _Tp>::cshift(int __n) const
0911e38f	266	{
	267	valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
	268	return __v;
	269	}
1d487aca	270
1d487aca	271	template<class _Clos, typename _Tp>
179fefb5	272	inline valarray<_Tp>
179fefb5	273	_Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
0911e38f	274	{
	275	valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
	276	return __v;
	277	}
bae9b8af	278
1d487aca	279	template<class _Clos, typename _Tp>
179fefb5	280	inline valarray<_Tp>
179fefb5	281	_Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
0911e38f	282	{
	283	valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
	284	return __v;
	285	}
1d487aca	286
179fefb5	287	// XXX: replace this with a more robust summation algorithm.
179fefb5	288	template<class _Clos, typename _Tp>
1d487aca	289	inline _Tp
7558da41	290	_Expr<_Clos, _Tp>::sum() const
1d487aca	291	{
179fefb5	292	size_t __n = _M_closure.size();
bae9b8af	293	if (__n == 0)
179fefb5	294	return _Tp();
bae9b8af	295	else
179fefb5	296	{
	297	_Tp __s = _M_closure[--__n];
	298	while (__n != 0)
	299	__s += _M_closure[--__n];
	300	return __s;
1d487aca	301	}
	302	}
	303
	304	template<class _Clos, typename _Tp>
179fefb5	305	inline _Tp
	306	_Expr<_Clos, _Tp>::min() const
	307	{ return __valarray_min(_M_closure); }
1d487aca	308
1d487aca	309	template<class _Clos, typename _Tp>
179fefb5	310	inline _Tp
	311	_Expr<_Clos, _Tp>::max() const
	312	{ return __valarray_max(_M_closure); }
bae9b8af	313
179fefb5	314	template<class _Dom, typename _Tp>
7558da41	315	inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
7558da41	316	_Expr<_Dom, _Tp>::operator!() const
1d487aca	317	{
7558da41	318	typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
5680197c	319	return _Expr<_Closure, bool>(_Closure(this->_M_closure));
1d487aca	320	}
1d487aca	321
acff9fb3	322	#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
acff9fb3	323	template<class _Dom, typename _Tp> \
7558da41	324	inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \
7558da41	325	_Expr<_Dom, _Tp>::operator _Op() const \
acff9fb3	326	{ \
7558da41	327	typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \
7558da41	328	return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \
acff9fb3	329	}
1d487aca	330
179fefb5	331	_DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
	332	_DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
	333	_DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
1d487aca	334
	335	#undef _DEFINE_EXPR_UNARY_OPERATOR
	336
1d487aca	337	#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
acff9fb3	338	template<class _Dom1, class _Dom2> \
7558da41	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	} \
1d487aca	349	\
7558da41	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	} \
1d487aca	362	\
7558da41	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	} \
1d487aca	375	\
7558da41	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	} \
1d487aca	388	\
7558da41	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	}
1d487aca	401
acff9fb3	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)
1d487aca	420
1d487aca	421	#undef _DEFINE_EXPR_BINARY_OPERATOR
1d487aca	422
c58969ac	423	#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName) \
acff9fb3	424	template<class _Dom> \
c58969ac	425	inline _Expr<_UnClos<_UName, _Expr, _Dom>, \
7558da41	426	typename _Dom::value_type> \
7558da41	427	_Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \
acff9fb3	428	{ \
acff9fb3	429	typedef typename _Dom::value_type _Tp; \
c58969ac	430	typedef _UnClos<_UName, _Expr, _Dom> _Closure; \
7558da41	431	return _Expr<_Closure, _Tp>(_Closure(__e())); \
acff9fb3	432	} \
	433	\
	434	template<typename _Tp> \
c58969ac	435	inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp> \
acff9fb3	436	_Name(const valarray<_Tp>& __v) \
acff9fb3	437	{ \
c58969ac	438	typedef _UnClos<_UName, _ValArray, _Tp> _Closure; \
7558da41	439	return _Expr<_Closure, _Tp>(_Closure(__v)); \
acff9fb3	440	}
1d487aca	441
c58969ac	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)
1d487aca	456
	457	#undef _DEFINE_EXPR_UNARY_FUNCTION
	458
c58969ac	459	#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun) \
acff9fb3	460	template<class _Dom1, class _Dom2> \
c58969ac	461	inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>, \
acff9fb3	462	typename _Dom1::value_type> \
7558da41	463	_Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \
c58969ac	464	const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \
acff9fb3	465	{ \
acff9fb3	466	typedef typename _Dom1::value_type _Tp; \
c58969ac	467	typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
7558da41	468	return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \
acff9fb3	469	} \
	470	\
	471	template<class _Dom> \
c58969ac	472	inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom, \
acff9fb3	473	typename _Dom::value_type>, \
acff9fb3	474	typename _Dom::value_type> \
7558da41	475	_Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
acff9fb3	476	const valarray<typename _Dom::value_type>& __v) \
	477	{ \
	478	typedef typename _Dom::value_type _Tp; \
c58969ac	479	typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure; \
7558da41	480	return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \
acff9fb3	481	} \
	482	\
	483	template<class _Dom> \
c58969ac	484	inline _Expr<_BinClos<_UFun, _ValArray, _Expr, \
7558da41	485	typename _Dom::value_type, _Dom>, \
acff9fb3	486	typename _Dom::value_type> \
acff9fb3	487	_Fun(const valarray<typename _Dom::valarray>& __v, \
7558da41	488	const _Expr<_Dom, typename _Dom::value_type>& __e) \
acff9fb3	489	{ \
acff9fb3	490	typedef typename _Dom::value_type _Tp; \
c58969ac	491	typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure; \
7558da41	492	return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \
acff9fb3	493	} \
	494	\
	495	template<class _Dom> \
c58969ac	496	inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom, \
acff9fb3	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; \
c58969ac	503	typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure; \
7558da41	504	return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \
acff9fb3	505	} \
	506	\
	507	template<class _Dom> \
c58969ac	508	inline _Expr<_BinClos<_UFun, _Constant, _Expr, \
7558da41	509	typename _Dom::value_type, _Dom>, \
acff9fb3	510	typename _Dom::value_type> \
acff9fb3	511	_Fun(const typename _Dom::value_type& __t, \
7558da41	512	const _Expr<_Dom, typename _Dom::value_type>& __e) \
acff9fb3	513	{ \
acff9fb3	514	typedef typename _Dom::value_type _Tp; \
c58969ac	515	typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure; \
7558da41	516	return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \
acff9fb3	517	} \
	518	\
	519	template<typename _Tp> \
c58969ac	520	inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
acff9fb3	521	_Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
acff9fb3	522	{ \
c58969ac	523	typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
7558da41	524	return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \
acff9fb3	525	} \
	526	\
	527	template<typename _Tp> \
c58969ac	528	inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
acff9fb3	529	_Fun(const valarray<_Tp>& __v, const _Tp& __t) \
acff9fb3	530	{ \
c58969ac	531	typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
7558da41	532	return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \
acff9fb3	533	} \
	534	\
	535	template<typename _Tp> \
c58969ac	536	inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
acff9fb3	537	_Fun(const _Tp& __t, const valarray<_Tp>& __v) \
acff9fb3	538	{ \
c58969ac	539	typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
7558da41	540	return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
acff9fb3	541	}
1d487aca	542
c58969ac	543	_DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)
c58969ac	544	_DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)
1d487aca	545
	546	#undef _DEFINE_EXPR_BINARY_FUNCTION
	547
2948dd21	548	_GLIBCXX_END_NAMESPACE_VERSION
2948dd21	549	} // namespace
1d487aca	550
6afba1a2	551	#endif /* _CPP_VALARRAY_AFTER_H */