From: Gabriel Dos Reis Date: Fri, 2 Aug 2002 18:10:38 +0000 (+0000) Subject: valarray_meta.h (_UnFunBase<>): Remove. X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=74d6b8ca6307ef057ba438f785f46eb9c911b184;p=platform%2Fupstream%2Fgcc.git valarray_meta.h (_UnFunBase<>): Remove. * include/bits/valarray_meta.h (_UnFunBase<>): Remove. (_UnFunClos<>): Same. (_UnBase<>): Reformat. Make first template-parameter non template. (_UnClos<>): Likewise. (_Expr<>): Reformate. Adjust unary member operator return types. (_DEFINE_EXPR_UNARY_OPERATOR): Adjust definition. (_DEFINE_EXPR_UNARY_FUNCTION): Likewise. * include/std/std_valarray.h (_UnClos<>): Adjust declaration. (valarray<>::_UnaryOp<>): New nested traits. Adjust unary member operator return types. Reformat. (_Bitwise_not): Remove. (_DEFINE_VALARRAY_UNARY_OPERATOR): Adjust definition. * testsuite/26_numerics/valarray_name_lookup.C: New test. From-SVN: r55993 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 7cdc71e..777f5e9 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,20 @@ +2002-08-02 Gabriel Dos Reis + + * include/bits/valarray_meta.h (_UnFunBase<>): Remove. + (_UnFunClos<>): Same. + (_UnBase<>): Reformat. Make first template-parameter non + template. + (_UnClos<>): Likewise. + (_Expr<>): Reformate. Adjust unary member operator return types. + (_DEFINE_EXPR_UNARY_OPERATOR): Adjust definition. + (_DEFINE_EXPR_UNARY_FUNCTION): Likewise. + * include/std/std_valarray.h (_UnClos<>): Adjust declaration. + (valarray<>::_UnaryOp<>): New nested traits. Adjust unary member + operator return types. Reformat. + (_Bitwise_not): Remove. + (_DEFINE_VALARRAY_UNARY_OPERATOR): Adjust definition. + * testsuite/26_numerics/valarray_name_lookup.C: New test. + 2002-08-02 Danny Smith * config/os/newlib/ctype_inline.h (is): Don't offset _M_table. diff --git a/libstdc++-v3/include/bits/valarray_meta.h b/libstdc++-v3/include/bits/valarray_meta.h index d5e758f..b077458 100644 --- a/libstdc++-v3/include/bits/valarray_meta.h +++ b/libstdc++-v3/include/bits/valarray_meta.h @@ -41,37 +41,18 @@ namespace std { - - // - // Implementing a loosened valarray return value is tricky. - // First we need to meet 26.3.1/3: we should not add more than - // two levels of template nesting. Therefore we resort to template - // template to "flatten" loosened return value types. - // At some point we use partial specialization to remove one level - // template nesting due to _Expr<> - // - - - // This class is NOT defined. It doesn't need to. - template class _Constant; - - // - // Unary function application closure. - // - template class _UnFunBase - { - public: - typedef typename _Dom::value_type value_type; - typedef value_type _Vt; - - explicit _UnFunBase (const _Dom& __e) : _M_expr(__e) {} - - _Vt operator[] (size_t __i) const { return _Op()(_M_expr[__i]); } - size_t size () const { return _M_expr.size(); } - - private: - const _Dom& _M_expr; - }; + // + // Implementing a loosened valarray return value is tricky. + // First we need to meet 26.3.1/3: we should not add more than + // two levels of template nesting. Therefore we resort to template + // template to "flatten" loosened return value types. + // At some point we use partial specialization to remove one level + // template nesting due to _Expr<> + // + + + // This class is NOT defined. It doesn't need to. + template class _Constant; // Implementations of unary functions applied to valarray<>s. // I use hard-coded object functions here instead of a generic @@ -399,27 +380,6 @@ namespace std typedef bool result_type; }; - template class _Meta, class _Dom, typename _Op> - class _UnFunClos; - - template - struct _UnFunClos<_Expr,_Dom, _Op> : _UnFunBase<_Dom, _Op> - { - typedef _UnFunBase<_Dom, _Op> _Base; - typedef typename _Base::value_type value_type; - - explicit _UnFunClos (const _Dom& __e) : _Base (__e) {} - }; - - template - struct _UnFunClos<_ValArray,_Tp, _Op> : _UnFunBase, _Op> - { - typedef _UnFunBase, _Op> _Base; - typedef typename _Base::value_type value_type; - - explicit _UnFunClos (const valarray<_Tp>& __v) : _Base (__v) {} - }; - // // Binary function application closure. // @@ -637,41 +597,42 @@ namespace std // Unary expression closure. // - template class _Oper, typename _Arg> - class _UnBase { + template + class _UnBase + { public: - typedef _Oper _Op; - typedef typename _Op::result_type value_type; + typedef typename _Arg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; - _UnBase (const _Arg& __e) : _M_expr(__e) {} - value_type operator[] (size_t) const; - size_t size () const { return _M_expr.size (); } + _UnBase(const _Arg& __e) : _M_expr(__e) {} + + value_type operator[](size_t __i) const + { return _M_expr[__i]; } + + size_t size() const { return _M_expr.size(); } private: - const _Arg& _M_expr; + const _Arg& _M_expr; }; - template class _Oper, typename _Arg> - inline typename _UnBase<_Oper, _Arg>::value_type - _UnBase<_Oper, _Arg>::operator[] (size_t __i) const - { return _Op() (_M_expr[__i]); } - - template class _Oper, class _Dom> - struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> { - typedef _Dom _Arg; - typedef _UnBase<_Oper, _Dom> _Base; - typedef typename _Base::value_type value_type; - - _UnClos (const _Arg& __e) : _Base(__e) {} + template + struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> + { + typedef _Dom _Arg; + typedef _UnBase<_Oper, _Dom> _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} }; - template class _Oper, typename _Tp> - struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > { - typedef valarray<_Tp> _Arg; - typedef _UnBase<_Oper, valarray<_Tp> > _Base; - typedef typename _Base::value_type value_type; - - _UnClos (const _Arg& __e) : _Base(__e) {} + template + struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > + { + typedef valarray<_Tp> _Arg; + typedef _UnBase<_Oper, valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} }; @@ -968,153 +929,158 @@ namespace std : _Base (__a, __i) {} }; - // - // class _Expr - // - template class _Expr { + // + // class _Expr + // + template + class _Expr + { public: - typedef _Tp value_type; - - _Expr (const _Clos&); - - const _Clos& operator() () const; + typedef _Tp value_type; + + _Expr(const _Clos&); + + const _Clos& operator()() const; - value_type operator[] (size_t) const; - valarray operator[] (slice) const; - valarray operator[] (const gslice&) const; - valarray operator[] (const valarray&) const; - valarray operator[] (const valarray&) const; + value_type operator[](size_t) const; + valarray operator[](slice) const; + valarray operator[](const gslice&) const; + valarray operator[](const valarray&) const; + valarray operator[](const valarray&) const; - _Expr<_UnClos<_Unary_plus,std::_Expr,_Clos>, value_type> - operator+ () const; + _Expr<_UnClos<__unary_plus,std::_Expr,_Clos>, value_type> + operator+() const; - _Expr<_UnClos, 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<__bitwise_not,std::_Expr,_Clos>, value_type> + operator~() const; - _Expr<_UnClos, bool> - operator! () const; + _Expr<_UnClos<__logical_not,std::_Expr,_Clos>, bool> + operator!() const; - size_t size () const; - value_type sum () const; + size_t size() const; + value_type sum() const; - valarray shift (int) const; - valarray cshift (int) const; + valarray shift(int) const; + valarray cshift(int) const; value_type min() const; value_type max() const; - valarray apply(value_type (*) (const value_type&)) const; - valarray apply(value_type (*) (value_type)) const; + valarray apply(value_type (*)(const value_type&)) const; + valarray apply(value_type (*)(value_type)) const; private: - const _Clos _M_closure; + const _Clos _M_closure; }; - template + template inline - _Expr<_Clos,_Tp>::_Expr (const _Clos& __c) : _M_closure(__c) {} + _Expr<_Clos,_Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} - template + template inline const _Clos& - _Expr<_Clos,_Tp>::operator() () const + _Expr<_Clos,_Tp>::operator()() const { return _M_closure; } - template + template inline _Tp - _Expr<_Clos,_Tp>::operator[] (size_t __i) const + _Expr<_Clos,_Tp>::operator[](size_t __i) const { return _M_closure[__i]; } - template + template inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (slice __s) const + _Expr<_Clos,_Tp>::operator[](slice __s) const { return _M_closure[__s]; } - template + template inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const gslice& __gs) const + _Expr<_Clos,_Tp>::operator[](const gslice& __gs) const { return _M_closure[__gs]; } - template + template inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray& __m) const + _Expr<_Clos,_Tp>::operator[](const valarray& __m) const { return _M_closure[__m]; } - template + template inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[] (const valarray& __i) const + _Expr<_Clos,_Tp>::operator[](const valarray& __i) const { return _M_closure[__i]; } - template + template inline size_t - _Expr<_Clos,_Tp>::size () const { return _M_closure.size (); } + _Expr<_Clos,_Tp>::size() const { return _M_closure.size (); } template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::shift(int __n) const - { return valarray<_Tp>(_M_closure).shift(__n); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::shift(int __n) const + { return valarray<_Tp>(_M_closure).shift(__n); } template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::cshift(int __n) const - { return valarray<_Tp>(_M_closure).cshift(__n); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::cshift(int __n) const + { return valarray<_Tp>(_M_closure).cshift(__n); } template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const - { return valarray<_Tp>(_M_closure).apply(__f); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const + { return valarray<_Tp>(_M_closure).apply(__f); } template - inline valarray<_Tp> - _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const - { return valarray<_Tp>(_M_closure).apply(__f); } + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const + { return valarray<_Tp>(_M_closure).apply(__f); } - // XXX: replace this with a more robust summation algorithm. - template + // XXX: replace this with a more robust summation algorithm. + template inline _Tp - _Expr<_Clos,_Tp>::sum () const + _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; + 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 - inline _Tp - _Expr<_Clos, _Tp>::min() const - { return __valarray_min(_M_closure); } + inline _Tp + _Expr<_Clos, _Tp>::min() const + { return __valarray_min(_M_closure); } template - inline _Tp - _Expr<_Clos, _Tp>::max() const - { return __valarray_max(_M_closure); } + inline _Tp + _Expr<_Clos, _Tp>::max() const + { return __valarray_max(_M_closure); } - template - inline _Expr<_UnClos, bool> - _Expr<_Dom,_Tp>::operator! () const + template + inline _Expr<_UnClos<__logical_not,_Expr,_Dom>, bool> + _Expr<_Dom,_Tp>::operator!() const { - typedef _UnClos _Closure; - return _Expr<_Closure,_Tp> (_Closure(this->_M_closure)); + typedef _UnClos<__logical_not,std::_Expr,_Dom> _Closure; + return _Expr<_Closure,_Tp>(_Closure(this->_M_closure)); } #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ template \ inline _Expr<_UnClos<_Name,std::_Expr,_Dom>,_Tp> \ -_Expr<_Dom,_Tp>::operator _Op () const \ +_Expr<_Dom,_Tp>::operator _Op() const \ { \ typedef _UnClos<_Name,std::_Expr,_Dom> _Closure; \ - return _Expr<_Closure,_Tp> (_Closure (this->_M_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) + _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_EXPR_UNARY_OPERATOR(-, __negate) + _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not) #undef _DEFINE_EXPR_UNARY_OPERATOR @@ -1263,19 +1229,19 @@ operator _Op (const valarray& __v, \ #define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \ template \ -inline _Expr<_UnFunClos<_Expr,_Dom,__##_Name>,typename _Dom::value_type>\ +inline _Expr<_UnClos<__##_Name,_Expr,_Dom>,typename _Dom::value_type> \ _Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \ { \ typedef typename _Dom::value_type _Tp; \ - typedef _UnFunClos<_Expr,_Dom,__##_Name> _Closure; \ + typedef _UnClos<__##_Name,_Expr,_Dom> _Closure; \ return _Expr<_Closure,_Tp>(_Closure(__e())); \ } \ \ template \ -inline _Expr<_UnFunClos<_ValArray,_Tp,__##_Name>,_Tp> \ +inline _Expr<_UnClos<__##_Name,_ValArray,_Tp>,_Tp> \ _Name(const valarray<_Tp>& __v) \ { \ - typedef _UnFunClos<_ValArray,_Tp,__##_Name> _Closure; \ + typedef _UnClos<__##_Name,_ValArray,_Tp> _Closure; \ return _Expr<_Closure,_Tp>(_Closure (__v)); \ } diff --git a/libstdc++-v3/include/std/std_valarray.h b/libstdc++-v3/include/std/std_valarray.h index d7bd7a4..6a6e59a 100644 --- a/libstdc++-v3/include/std/std_valarray.h +++ b/libstdc++-v3/include/std/std_valarray.h @@ -50,43 +50,49 @@ namespace std { - template class _Expr; + template + class _Expr; - template class _ValArray; + template + class _ValArray; - template class _Oper, - template class _Meta, class _Dom> struct _UnClos; + template class _Meta, class _Dom> + struct _UnClos; - template class _Oper, + template class _Oper, template class _Meta1, template class _Meta2, - class _Dom1, class _Dom2> class _BinClos; + class _Dom1, class _Dom2> + class _BinClos; - template class _Meta, class _Dom> class _SClos; + template class _Meta, class _Dom> + class _SClos; - template class _Meta, class _Dom> class _GClos; + template class _Meta, class _Dom> + class _GClos; - template class _Meta, class _Dom> class _IClos; + template class _Meta, class _Dom> + class _IClos; - template class _Meta, class _Dom> class _ValFunClos; - - template class _Meta, class _Dom> class _RefFunClos; - - template struct _Unary_plus; - template struct _Bitwise_and; - template struct _Bitwise_or; - template struct _Bitwise_xor; - template struct _Bitwise_not; - template struct _Shift_left; - template struct _Shift_right; + template class _Meta, class _Dom> + class _ValFunClos; - template class valarray; // An array of type _Tp - class slice; // BLAS-like slice out of an array - template class slice_array; - class gslice; // generalized slice out of an array - template class gslice_array; - template class mask_array; // masked array - template class indirect_array; // indirected array + template class _Meta, class _Dom> + class _RefFunClos; + + template struct _Bitwise_and; + template struct _Bitwise_or; + template struct _Bitwise_xor; + template struct _Shift_left; + template struct _Shift_right; + + template class valarray; // An array of type _Tp + class slice; // BLAS-like slice out of an array + template class slice_array; + class gslice; // generalized slice out of an array + template class gslice_array; + template class mask_array; // masked array + template class indirect_array; // indirected array } // namespace std @@ -95,12 +101,19 @@ namespace std namespace std { - template class valarray - { - public: + template + class valarray + { + template + struct _UnaryOp + { + typedef typename __fun<_Op, _Tp>::result_type __rt; + typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; + }; + public: typedef _Tp value_type; - - // _lib.valarray.cons_ construct/destroy: + + // _lib.valarray.cons_ construct/destroy: valarray(); explicit valarray(size_t); valarray(const _Tp&, size_t); @@ -111,8 +124,8 @@ namespace std valarray(const mask_array<_Tp>&); valarray(const indirect_array<_Tp>&); template - valarray(const _Expr<_Dom,_Tp>& __e); - ~valarray(); + valarray(const _Expr<_Dom,_Tp>& __e); + ~valarray(); // _lib.valarray.assign_ assignment: valarray<_Tp>& operator=(const valarray<_Tp>&); @@ -123,7 +136,7 @@ namespace std valarray<_Tp>& operator=(const indirect_array<_Tp>&); template valarray<_Tp>& - operator= (const _Expr<_Dom,_Tp>&); + operator= (const _Expr<_Dom,_Tp>&); // _lib.valarray.access_ element access: // XXX: LWG to be resolved. @@ -137,67 +150,67 @@ namespace std valarray<_Tp> operator[](const valarray&) const; mask_array<_Tp> operator[](const valarray&); _Expr<_IClos<_ValArray, _Tp>, _Tp> - operator[](const valarray&) const; + operator[](const valarray&) const; indirect_array<_Tp> operator[](const valarray&); // _lib.valarray.unary_ unary operators: - _Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const; - _Expr<_UnClos,_Tp> operator- () const; - _Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const; - _Expr<_UnClos,bool> operator! () const; - + typename _UnaryOp<__unary_plus>::_Rt operator+() const; + typename _UnaryOp<__negate>::_Rt operator-() const; + typename _UnaryOp<__bitwise_not>::_Rt operator~() const; + typename _UnaryOp<__logical_not>::_Rt operator!() const; + // _lib.valarray.cassign_ computed assignment: - valarray<_Tp>& operator*= (const _Tp&); - valarray<_Tp>& operator/= (const _Tp&); - valarray<_Tp>& operator%= (const _Tp&); - valarray<_Tp>& operator+= (const _Tp&); - valarray<_Tp>& operator-= (const _Tp&); - valarray<_Tp>& operator^= (const _Tp&); - valarray<_Tp>& operator&= (const _Tp&); - valarray<_Tp>& operator|= (const _Tp&); + valarray<_Tp>& operator*=(const _Tp&); + valarray<_Tp>& operator/=(const _Tp&); + valarray<_Tp>& operator%=(const _Tp&); + valarray<_Tp>& operator+=(const _Tp&); + valarray<_Tp>& operator-=(const _Tp&); + valarray<_Tp>& operator^=(const _Tp&); + valarray<_Tp>& operator&=(const _Tp&); + valarray<_Tp>& operator|=(const _Tp&); valarray<_Tp>& operator<<=(const _Tp&); valarray<_Tp>& operator>>=(const _Tp&); - valarray<_Tp>& operator*= (const valarray<_Tp>&); - valarray<_Tp>& operator/= (const valarray<_Tp>&); - valarray<_Tp>& operator%= (const valarray<_Tp>&); - valarray<_Tp>& operator+= (const valarray<_Tp>&); - valarray<_Tp>& operator-= (const valarray<_Tp>&); - valarray<_Tp>& operator^= (const valarray<_Tp>&); - valarray<_Tp>& operator|= (const valarray<_Tp>&); - valarray<_Tp>& operator&= (const valarray<_Tp>&); + valarray<_Tp>& operator*=(const valarray<_Tp>&); + valarray<_Tp>& operator/=(const valarray<_Tp>&); + valarray<_Tp>& operator%=(const valarray<_Tp>&); + valarray<_Tp>& operator+=(const valarray<_Tp>&); + valarray<_Tp>& operator-=(const valarray<_Tp>&); + valarray<_Tp>& operator^=(const valarray<_Tp>&); + valarray<_Tp>& operator|=(const valarray<_Tp>&); + valarray<_Tp>& operator&=(const valarray<_Tp>&); valarray<_Tp>& operator<<=(const valarray<_Tp>&); valarray<_Tp>& operator>>=(const valarray<_Tp>&); template - valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator*=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator/=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator%=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator+=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator-=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator^=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator|=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); template - valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&); + valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&); + - // _lib.valarray.members_ member functions: size_t size() const; _Tp sum() const; _Tp min() const; _Tp max() const; -// // FIXME: Extension -// _Tp product () const; + // // FIXME: Extension + // _Tp product () const; valarray<_Tp> shift (int) const; valarray<_Tp> cshift(int) const; @@ -205,17 +218,12 @@ namespace std _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const; void resize(size_t __size, _Tp __c = _Tp()); - private: + private: size_t _M_size; _Tp* __restrict__ _M_data; - + friend class _Array<_Tp>; - }; - - - template struct _Unary_plus : unary_function<_Tp,_Tp> { - _Tp operator() (const _Tp& __t) const { return __t; } - }; + }; template struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> { _Tp operator() (_Tp __x, _Tp __y) const { return __x & __y; } @@ -229,10 +237,6 @@ namespace std _Tp operator() (_Tp __x, _Tp __y) const { return __x ^ __y; } }; - template struct _Bitwise_not : unary_function<_Tp,_Tp> { - _Tp operator() (_Tp __t) const { return ~__t; } - }; - template struct _Shift_left : unary_function<_Tp,_Tp> { _Tp operator() (_Tp __x, _Tp __y) const { return __x << __y; } }; @@ -243,14 +247,14 @@ namespace std template - inline const _Tp& - valarray<_Tp>::operator[] (size_t __i) const - { return _M_data[__i]; } + inline const _Tp& + valarray<_Tp>::operator[](size_t __i) const + { return _M_data[__i]; } template - inline _Tp& - valarray<_Tp>::operator[] (size_t __i) - { return _M_data[__i]; } + inline _Tp& + valarray<_Tp>::operator[](size_t __i) + { return _M_data[__i]; } } // std:: @@ -263,214 +267,227 @@ namespace std namespace std { template - inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {} + inline + valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} template - inline valarray<_Tp>::valarray (size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_default_construct(_M_data, _M_data + __n); } + inline + valarray<_Tp>::valarray(size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_default_construct(_M_data, _M_data + __n); } template - inline valarray<_Tp>::valarray (const _Tp& __t, size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_fill_construct (_M_data, _M_data + __n, __t); } + inline + valarray<_Tp>::valarray(const _Tp& __t, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_fill_construct(_M_data, _M_data + __n, __t); } template - inline valarray<_Tp>::valarray (const _Tp* __restrict__ __p, size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { __valarray_copy_construct (__p, __p + __n, _M_data); } + inline + valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { __valarray_copy_construct(__p, __p + __n, _M_data); } template - inline valarray<_Tp>::valarray (const valarray<_Tp>& __v) - : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) - { __valarray_copy_construct (__v._M_data, __v._M_data + _M_size, _M_data); } + inline + valarray<_Tp>::valarray(const valarray<_Tp>& __v) + : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) + { __valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } template - inline valarray<_Tp>::valarray (const slice_array<_Tp>& __sa) - : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) - { - __valarray_copy - (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); - } + inline + valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) + : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) + { + __valarray_copy + (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); + } template - inline valarray<_Tp>::valarray (const gslice_array<_Tp>& __ga) - : _M_size(__ga._M_index.size()), - _M_data(__valarray_get_storage<_Tp>(_M_size)) - { - __valarray_copy - (__ga._M_array, _Array(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) + : _M_size(__ga._M_index.size()), + _M_data(__valarray_get_storage<_Tp>(_M_size)) + { + __valarray_copy + (__ga._M_array, _Array(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); + } template - inline valarray<_Tp>::valarray (const mask_array<_Tp>& __ma) - : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) - { - __valarray_copy - (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) + : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) + { + __valarray_copy + (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); + } template - inline valarray<_Tp>::valarray (const indirect_array<_Tp>& __ia) - : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) - { - __valarray_copy - (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); - } + inline + valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) + : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) + { + __valarray_copy + (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); + } template template - inline valarray<_Tp>::valarray (const _Expr<_Dom, _Tp>& __e) - : _M_size(__e.size ()), _M_data(__valarray_get_storage<_Tp>(_M_size)) - { __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); } + inline + valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) + : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) + { __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); } template - inline valarray<_Tp>::~valarray () - { + inline + valarray<_Tp>::~valarray() + { __valarray_destroy_elements(_M_data, _M_data + _M_size); __valarray_release_memory(_M_data); - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const valarray<_Tp>& __v) - { + inline valarray<_Tp>& + valarray<_Tp>::operator=(const valarray<_Tp>& __v) + { __valarray_copy(__v._M_data, _M_size, _M_data); return *this; - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Tp& __t) - { - __valarray_fill (_M_data, _M_size, __t); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Tp& __t) + { + __valarray_fill(_M_data, _M_size, __t); return *this; - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const slice_array<_Tp>& __sa) - { - __valarray_copy (__sa._M_array, __sa._M_sz, - __sa._M_stride, _Array<_Tp>(_M_data)); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) + { + __valarray_copy(__sa._M_array, __sa._M_sz, + __sa._M_stride, _Array<_Tp>(_M_data)); return *this; - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const gslice_array<_Tp>& __ga) - { - __valarray_copy (__ga._M_array, _Array(__ga._M_index), - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) + { + __valarray_copy(__ga._M_array, _Array(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const mask_array<_Tp>& __ma) - { - __valarray_copy (__ma._M_array, __ma._M_mask, - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) + { + __valarray_copy(__ma._M_array, __ma._M_mask, + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const indirect_array<_Tp>& __ia) - { - __valarray_copy (__ia._M_array, __ia._M_index, - _Array<_Tp>(_M_data), _M_size); + inline valarray<_Tp>& + valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) + { + __valarray_copy(__ia._M_array, __ia._M_index, + _Array<_Tp>(_M_data), _M_size); return *this; - } + } template template - inline valarray<_Tp>& - valarray<_Tp>::operator= (const _Expr<_Dom, _Tp>& __e) - { - __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); - return *this; - } + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) + { + __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); + return *this; + } template - inline _Expr<_SClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (slice __s) const - { + inline _Expr<_SClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](slice __s) const + { typedef _SClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure, _Tp> (_Closure (_Array<_Tp>(_M_data), __s)); - } + return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); + } template - inline slice_array<_Tp> - valarray<_Tp>::operator[] (slice __s) - { - return slice_array<_Tp> (_Array<_Tp>(_M_data), __s); - } + inline slice_array<_Tp> + valarray<_Tp>::operator[](slice __s) + { + return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); + } template - inline _Expr<_GClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (const gslice& __gs) const - { + inline _Expr<_GClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const gslice& __gs) const + { typedef _GClos<_ValArray,_Tp> _Closure; return _Expr<_Closure, _Tp> - (_Closure (_Array<_Tp>(_M_data), __gs._M_index->_M_index)); - } + (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); + } template - inline gslice_array<_Tp> - valarray<_Tp>::operator[] (const gslice& __gs) - { + inline gslice_array<_Tp> + valarray<_Tp>::operator[](const gslice& __gs) + { return gslice_array<_Tp> - (_Array<_Tp>(_M_data), __gs._M_index->_M_index); - } + (_Array<_Tp>(_M_data), __gs._M_index->_M_index); + } template - inline valarray<_Tp> - valarray<_Tp>::operator[] (const valarray& __m) const - { - size_t __s (0); - size_t __e (__m.size ()); + inline valarray<_Tp> + valarray<_Tp>::operator[](const valarray& __m) const + { + size_t __s = 0; + size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) - if (__m[__i]) ++__s; - return valarray<_Tp> (mask_array<_Tp> (_Array<_Tp>(_M_data), __s, - _Array (__m))); - } + if (__m[__i]) ++__s; + return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, + _Array (__m))); + } template - inline mask_array<_Tp> - valarray<_Tp>::operator[] (const valarray& __m) - { - size_t __s (0); - size_t __e (__m.size ()); + inline mask_array<_Tp> + valarray<_Tp>::operator[](const valarray& __m) + { + size_t __s = 0; + size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) - if (__m[__i]) ++__s; - return mask_array<_Tp> (_Array<_Tp>(_M_data), __s, _Array (__m)); - } + if (__m[__i]) ++__s; + return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array(__m)); + } template - inline _Expr<_IClos<_ValArray,_Tp>, _Tp> - valarray<_Tp>::operator[] (const valarray& __i) const - { + inline _Expr<_IClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const valarray& __i) const + { typedef _IClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure, _Tp> (_Closure (*this, __i)); - } + return _Expr<_Closure, _Tp>(_Closure(*this, __i)); + } template - inline indirect_array<_Tp> - valarray<_Tp>::operator[] (const valarray& __i) - { - return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(), - _Array (__i)); - } + inline indirect_array<_Tp> + valarray<_Tp>::operator[](const valarray& __i) + { + return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), + _Array(__i)); + } template - inline size_t valarray<_Tp>::size () const { return _M_size; } + inline size_t + valarray<_Tp>::size() const + { return _M_size; } template - inline _Tp - valarray<_Tp>::sum () const - { - return __valarray_sum(_M_data, _M_data + _M_size); - } + inline _Tp + valarray<_Tp>::sum() const + { + return __valarray_sum(_M_data, _M_data + _M_size); + } // template // inline _Tp @@ -529,74 +546,68 @@ namespace std } template - inline void - valarray<_Tp>::resize (size_t __n, _Tp __c) - { - // This complication is so to make valarray > work - // even though it is not required by the standard. Nobody should - // be saying valarray > anyway. See the specs. - __valarray_destroy_elements(_M_data, _M_data + _M_size); - if (_M_size != __n) - { - __valarray_release_memory(_M_data); - _M_size = __n; - _M_data = __valarray_get_storage<_Tp>(__n); - } - __valarray_fill_construct(_M_data, _M_data + __n, __c); - } + inline void + valarray<_Tp>::resize (size_t __n, _Tp __c) + { + // This complication is so to make valarray > work + // even though it is not required by the standard. Nobody should + // be saying valarray > anyway. See the specs. + __valarray_destroy_elements(_M_data, _M_data + _M_size); + if (_M_size != __n) + { + __valarray_release_memory(_M_data); + _M_size = __n; + _M_data = __valarray_get_storage<_Tp>(__n); + } + __valarray_fill_construct(_M_data, _M_data + __n, __c); + } template - inline _Tp - valarray<_Tp>::min() const - { + inline _Tp + valarray<_Tp>::min() const + { return *min_element (_M_data, _M_data+_M_size); - } + } template - inline _Tp - valarray<_Tp>::max() const - { + inline _Tp + valarray<_Tp>::max() const + { return *max_element (_M_data, _M_data+_M_size); - } + } template - inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> - valarray<_Tp>::apply (_Tp func (_Tp)) const - { + inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> + valarray<_Tp>::apply(_Tp func(_Tp)) const + { typedef _ValFunClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure,_Tp> (_Closure (*this, func)); - } + return _Expr<_Closure,_Tp>(_Closure(*this, func)); + } template - inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> - valarray<_Tp>::apply (_Tp func (const _Tp &)) const - { + inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> + valarray<_Tp>::apply(_Tp func(const _Tp &)) const + { typedef _RefFunClos<_ValArray,_Tp> _Closure; - return _Expr<_Closure,_Tp> (_Closure (*this, func)); - } + return _Expr<_Closure,_Tp>(_Closure(*this, func)); + } #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ template \ - inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \ + inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ valarray<_Tp>::operator _Op() const \ { \ - typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ - return _Expr<_Closure, _Tp> (_Closure (*this)); \ + typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(*this)); \ } - _DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus) - _DEFINE_VALARRAY_UNARY_OPERATOR(-, negate) - _DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not) + _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate) + _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not) + _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not) #undef _DEFINE_VALARRAY_UNARY_OPERATOR - - template - inline _Expr<_UnClos, bool> - valarray<_Tp>::operator!() const - { - typedef _UnClos _Closure; - return _Expr<_Closure, bool> (_Closure (*this)); - } #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ template \ diff --git a/libstdc++-v3/testsuite/26_numerics/valarray_name_lookup.C b/libstdc++-v3/testsuite/26_numerics/valarray_name_lookup.C new file mode 100644 index 0000000..4958b36 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray_name_lookup.C @@ -0,0 +1,119 @@ +// 2002-08-02 gdr + +// Copyright (C) 2002 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 2, 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +// Test name lookup resolutions for standard functions applied to an +// array expression. +// { dg-do compile } + +#include + +namespace My +{ + struct Number + { + operator bool() const; + }; + + Number operator+(Number); + Number operator-(Number); + Number operator~(Number); + + bool operator!(Number); + + Number operator+(Number, Number); + Number operator-(Number, Number); + Number operator*(Number, Number); + Number operator/(Number, Number); + Number operator%(Number, Number); + + Number operator^(Number, Number); + Number operator&(Number, Number); + Number operator|(Number, Number); + + Number operator<<(Number, Number); + Number operator>>(Number, Number); + + bool operator==(Number, Number); + bool operator!=(Number, Number); + bool operator<(Number, Number); + bool operator<=(Number, Number); + bool operator>(Number, Number); + bool operator>=(Number, Number); + + Number abs(Number); + + Number cos(Number); + Number cosh(Number); + Number acosh(Number); + + Number sin(Number); + Number sinh(Number); + Number asin(Number); + + Number tan(Number); + Number tanh(Number); + Number atan(Number); + + Number exp(Number); + Number log(Number); + Number log10(Number); + Number sqrt(Number); + + Number atan2(Number, Number); + Number pow(Number, Number); +} + +int main() +{ + typedef std::valarray Array; + Array u(10), v(10); + v = +u; + v = -u; + v = ~u; + std::valarray z = !u; + + v = abs(u); + + v = cos(u); + v = cosh(u); + v = acos(u); + + v = sin(u); + v = sinh(u); + v = asin(u); + + v = tan(u); + v = tanh(u); + v = atan(u); + + v = exp(u); + v = log(u); + v = log10(u); + v = sqrt(u); +}