From b714a4192e2ec903b99d1d8a7c664fab099f4908 Mon Sep 17 00:00:00 2001 From: Paolo Carlini Date: Thu, 8 Jul 2004 20:48:04 +0000 Subject: [PATCH] gslice.h: Trivial formatting fixes. 2004-07-08 Paolo Carlini * include/bits/gslice.h: Trivial formatting fixes. * include/bits/gslice_array.h: Likewise. * include/bits/indirect_array.h: Likewise. * include/bits/mask_array.h: Likewise. * include/bits/slice_array.h: Likewise. * include/bits/valarray_after.h: Likewise. * include/bits/valarray_array.h: Likewise. * include/bits/valarray_before.h: Likewise. * include/std/std_valarray.h: Likewise. From-SVN: r84312 --- libstdc++-v3/ChangeLog | 12 + libstdc++-v3/include/bits/gslice.h | 181 ++++----- libstdc++-v3/include/bits/gslice_array.h | 30 +- libstdc++-v3/include/bits/indirect_array.h | 1 - libstdc++-v3/include/bits/mask_array.h | 7 +- libstdc++-v3/include/bits/slice_array.h | 28 +- libstdc++-v3/include/bits/valarray_after.h | 395 ++++++++++--------- libstdc++-v3/include/bits/valarray_array.h | 400 ++++++++++++-------- libstdc++-v3/include/bits/valarray_before.h | 228 ++++++----- libstdc++-v3/include/std/std_valarray.h | 164 ++++---- 10 files changed, 798 insertions(+), 648 deletions(-) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 17819c9acc5..4b0036b3bc6 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,15 @@ +2004-07-08 Paolo Carlini + + * include/bits/gslice.h: Trivial formatting fixes. + * include/bits/gslice_array.h: Likewise. + * include/bits/indirect_array.h: Likewise. + * include/bits/mask_array.h: Likewise. + * include/bits/slice_array.h: Likewise. + * include/bits/valarray_after.h: Likewise. + * include/bits/valarray_array.h: Likewise. + * include/bits/valarray_before.h: Likewise. + * include/std/std_valarray.h: Likewise. + 2004-07-08 Benjamin Kosnik PR c++/16169 diff --git a/libstdc++-v3/include/bits/gslice.h b/libstdc++-v3/include/bits/gslice.h index 78f8a67146b..2dd2cab3e5a 100644 --- a/libstdc++-v3/include/bits/gslice.h +++ b/libstdc++-v3/include/bits/gslice.h @@ -40,8 +40,8 @@ #pragma GCC system_header -namespace std { - +namespace std +{ /** * @brief Class defining multi-dimensional subset of an array. * @@ -60,104 +60,113 @@ namespace std { * slice[0,2]==array[9], slice[1,0]==array[14], slice[1,1]==array[17], * slice[1,2]==array[20]. */ - class gslice + class gslice + { + public: + /// Construct an empty slice. + gslice (); + + /** + * @brief Construct a slice. + * + * Constructs a slice with as many dimensions as the length of the @a l + * and @a s arrays. + * + * @param o Offset in array of first element. + * @param l Array of dimension lengths. + * @param s Array of dimension strides between array elements. + */ + gslice(size_t, const valarray&, const valarray&); + + // XXX: the IS says the copy-ctor and copy-assignment operators are + // synthetized by the compiler but they are just unsuitable + // for a ref-counted semantic + /// Copy constructor. + gslice(const gslice&); + + /// Destructor. + ~gslice(); + + // XXX: See the note above. + /// Assignment operator. + gslice& operator=(const gslice&); + + /// Return array offset of first slice element. + size_t start() const; + + /// Return array of sizes of slice dimensions. + valarray size() const; + + /// Return array of array strides for each dimension. + valarray stride() const; + + private: + struct _Indexer { - public: - /// Construct an empty slice. - gslice (); - - /** - * @brief Construct a slice. - * - * Constructs a slice with as many dimensions as the length of the @a l - * and @a s arrays. - * - * @param o Offset in array of first element. - * @param l Array of dimension lengths. - * @param s Array of dimension strides between array elements. - */ - gslice(size_t, const valarray&, const valarray&); - - // XXX: the IS says the copy-ctor and copy-assignment operators are - // synthetized by the compiler but they are just unsuitable - // for a ref-counted semantic - /// Copy constructor. - gslice(const gslice&); - - /// Destructor. - ~gslice(); - - // XXX: See the note above. - /// Assignment operator. - gslice& operator=(const gslice&); - - /// Return array offset of first slice element. - size_t start() const; - - /// Return array of sizes of slice dimensions. - valarray size() const; - - /// Return array of array strides for each dimension. - valarray stride() const; - - private: - struct _Indexer { - size_t _M_count; - size_t _M_start; - valarray _M_size; - valarray _M_stride; - valarray _M_index; // Linear array of referenced indices - _Indexer(size_t, const valarray&, - const valarray&); - void _M_increment_use() { ++_M_count; } - size_t _M_decrement_use() { return --_M_count; } - }; - - _Indexer* _M_index; - - template friend class valarray; + size_t _M_count; + size_t _M_start; + valarray _M_size; + valarray _M_stride; + valarray _M_index; // Linear array of referenced indices + _Indexer(size_t, const valarray&, + const valarray&); + void + _M_increment_use() + { ++_M_count; } + + size_t + _M_decrement_use() + { return --_M_count; } }; - inline size_t - gslice::start () const - { return _M_index ? _M_index->_M_start : 0; } + _Indexer* _M_index; - inline valarray - gslice::size () const - { return _M_index ? _M_index->_M_size : valarray(); } + template friend class valarray; + }; - inline valarray - gslice::stride () const - { return _M_index ? _M_index->_M_stride : valarray(); } + inline size_t + gslice::start () const + { return _M_index ? _M_index->_M_start : 0; } - inline gslice::gslice () : _M_index(0) {} + inline valarray + gslice::size () const + { return _M_index ? _M_index->_M_size : valarray(); } - inline - gslice::gslice(size_t __o, const valarray& __l, - const valarray& __s) - : _M_index(new gslice::_Indexer(__o, __l, __s)) {} + inline valarray + gslice::stride () const + { return _M_index ? _M_index->_M_stride : valarray(); } - inline - gslice::gslice(const gslice& __g) : _M_index(__g._M_index) - { if (_M_index) _M_index->_M_increment_use(); } + inline gslice::gslice () : _M_index(0) {} - inline - gslice::~gslice() - { if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; } + inline + gslice::gslice(size_t __o, const valarray& __l, + const valarray& __s) + : _M_index(new gslice::_Indexer(__o, __l, __s)) {} - inline gslice& - gslice::operator= (const gslice& __g) - { - if (__g._M_index) __g._M_index->_M_increment_use(); - if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; - _M_index = __g._M_index; - return *this; - } + inline + gslice::gslice(const gslice& __g) : _M_index(__g._M_index) + { if (_M_index) _M_index->_M_increment_use(); } + inline + gslice::~gslice() + { + if (_M_index && _M_index->_M_decrement_use() == 0) + delete _M_index; + } + + inline gslice& + gslice::operator= (const gslice& __g) + { + if (__g._M_index) + __g._M_index->_M_increment_use(); + if (_M_index && _M_index->_M_decrement_use() == 0) + delete _M_index; + _M_index = __g._M_index; + return *this; + } } // std:: - #endif /* _GSLICE_H */ // Local Variables: diff --git a/libstdc++-v3/include/bits/gslice_array.h b/libstdc++-v3/include/bits/gslice_array.h index 7e2e6848e88..f0f9eec29aa 100644 --- a/libstdc++-v3/include/bits/gslice_array.h +++ b/libstdc++-v3/include/bits/gslice_array.h @@ -40,8 +40,8 @@ #pragma GCC system_header -namespace std { - +namespace std +{ /** * @brief Reference to multi-dimensional subset of an array. * @@ -97,27 +97,27 @@ namespace std { void operator=(const _Tp&) const; template - void operator=(const _Expr<_Dom,_Tp>&) const; + void operator=(const _Expr<_Dom, _Tp>&) const; template - void operator*=(const _Expr<_Dom,_Tp>&) const; + void operator*=(const _Expr<_Dom, _Tp>&) const; template - void operator/=(const _Expr<_Dom,_Tp>&) const; + void operator/=(const _Expr<_Dom, _Tp>&) const; template - void operator%=(const _Expr<_Dom,_Tp>&) const; + void operator%=(const _Expr<_Dom, _Tp>&) const; template - void operator+=(const _Expr<_Dom,_Tp>&) const; + void operator+=(const _Expr<_Dom, _Tp>&) const; template - void operator-=(const _Expr<_Dom,_Tp>&) const; + void operator-=(const _Expr<_Dom, _Tp>&) const; template - void operator^=(const _Expr<_Dom,_Tp>&) const; + void operator^=(const _Expr<_Dom, _Tp>&) const; template - void operator&=(const _Expr<_Dom,_Tp>&) const; + void operator&=(const _Expr<_Dom, _Tp>&) const; template - void operator|=(const _Expr<_Dom,_Tp>&) const; + void operator|=(const _Expr<_Dom, _Tp>&) const; template - void operator<<=(const _Expr<_Dom,_Tp>&) const; + void operator<<=(const _Expr<_Dom, _Tp>&) const; template - void operator>>=(const _Expr<_Dom,_Tp>&) const; + void operator>>=(const _Expr<_Dom, _Tp>&) const; private: _Array<_Tp> _M_array; @@ -137,13 +137,11 @@ namespace std { const valarray& __i) : _M_array(__a), _M_index(__i) {} - template inline gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a) : _M_array(__a._M_array), _M_index(__a._M_index) {} - template inline gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a) @@ -186,7 +184,7 @@ namespace std { gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \ { \ _Array_augmented_##_Name(_M_array, _Array(_M_index), \ - _Array<_Tp>(__v), __v.size()); \ + _Array<_Tp>(__v), __v.size()); \ } \ \ template \ diff --git a/libstdc++-v3/include/bits/indirect_array.h b/libstdc++-v3/include/bits/indirect_array.h index 912f522450d..b5de990df36 100644 --- a/libstdc++-v3/include/bits/indirect_array.h +++ b/libstdc++-v3/include/bits/indirect_array.h @@ -156,7 +156,6 @@ namespace std return *this; } - template inline void indirect_array<_Tp>::operator=(const _Tp& __t) const diff --git a/libstdc++-v3/include/bits/mask_array.h b/libstdc++-v3/include/bits/mask_array.h index 1a694f3c61f..03933578d40 100644 --- a/libstdc++-v3/include/bits/mask_array.h +++ b/libstdc++-v3/include/bits/mask_array.h @@ -40,8 +40,8 @@ #pragma GCC system_header -namespace std { - +namespace std +{ /** * @brief Reference to selected subset of an array. * @@ -128,13 +128,12 @@ namespace std { const size_t _M_sz; const _Array _M_mask; - const _Array<_Tp> _M_array; + const _Array<_Tp> _M_array; // not implemented mask_array(); }; - template inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a) : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {} diff --git a/libstdc++-v3/include/bits/slice_array.h b/libstdc++-v3/include/bits/slice_array.h index 31c89bcdb61..42da0d22455 100644 --- a/libstdc++-v3/include/bits/slice_array.h +++ b/libstdc++-v3/include/bits/slice_array.h @@ -90,7 +90,7 @@ namespace std inline slice::slice(size_t __o, size_t __d, size_t __s) - : _M_off(__o), _M_sz(__d), _M_st(__s) {} + : _M_off(__o), _M_sz(__d), _M_st(__s) {} inline size_t slice::start() const @@ -160,34 +160,34 @@ namespace std // ~slice_array (); template - void operator=(const _Expr<_Dom,_Tp>&) const; + void operator=(const _Expr<_Dom, _Tp>&) const; template - void operator*=(const _Expr<_Dom,_Tp>&) const; + void operator*=(const _Expr<_Dom, _Tp>&) const; template - void operator/=(const _Expr<_Dom,_Tp>&) const; + void operator/=(const _Expr<_Dom, _Tp>&) const; template - void operator%=(const _Expr<_Dom,_Tp>&) const; + void operator%=(const _Expr<_Dom, _Tp>&) const; template - void operator+=(const _Expr<_Dom,_Tp>&) const; + void operator+=(const _Expr<_Dom, _Tp>&) const; template - void operator-=(const _Expr<_Dom,_Tp>&) const; + void operator-=(const _Expr<_Dom, _Tp>&) const; template - void operator^=(const _Expr<_Dom,_Tp>&) const; + void operator^=(const _Expr<_Dom, _Tp>&) const; template - void operator&=(const _Expr<_Dom,_Tp>&) const; + void operator&=(const _Expr<_Dom, _Tp>&) const; template - void operator|=(const _Expr<_Dom,_Tp>&) const; + void operator|=(const _Expr<_Dom, _Tp>&) const; template - void operator<<=(const _Expr<_Dom,_Tp>&) const; + void operator<<=(const _Expr<_Dom, _Tp>&) const; template - void operator>>=(const _Expr<_Dom,_Tp>&) const; + void operator>>=(const _Expr<_Dom, _Tp>&) const; private: friend class valarray<_Tp>; slice_array(_Array<_Tp>, const slice&); - const size_t _M_sz; - const size_t _M_stride; + const size_t _M_sz; + const size_t _M_stride; const _Array<_Tp> _M_array; // not implemented diff --git a/libstdc++-v3/include/bits/valarray_after.h b/libstdc++-v3/include/bits/valarray_after.h index b74cab5dbac..e2311275e45 100644 --- a/libstdc++-v3/include/bits/valarray_after.h +++ b/libstdc++-v3/include/bits/valarray_after.h @@ -1,6 +1,7 @@ // The template and inlines for the -*- C++ -*- internal _Meta class. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 +// 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 @@ -41,92 +42,120 @@ namespace std { - - // - // gslice_array closure. - // - template class _GBase { + // + // gslice_array closure. + // + template + class _GBase + { public: - typedef typename _Dom::value_type value_type; - - _GBase (const _Dom& __e, const valarray& __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(); } + typedef typename _Dom::value_type value_type; + + _GBase (const _Dom& __e, const valarray& __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& _M_index; + const _Dom& _M_expr; + const valarray& _M_index; }; - template class _GBase<_Array<_Tp> > { + template + class _GBase<_Array<_Tp> > + { public: - typedef _Tp value_type; - - _GBase (_Array<_Tp> __a, const valarray& __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(); } + typedef _Tp value_type; + + _GBase (_Array<_Tp> __a, const valarray& __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& _M_index; + const _Array<_Tp> _M_array; + const valarray& _M_index; }; - template struct _GClos<_Expr,_Dom> : _GBase<_Dom> { - typedef _GBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _GClos (const _Dom& __e, const valarray& __i) - : _Base (__e, __i) {} + template + struct _GClos<_Expr, _Dom> + : _GBase<_Dom> + { + typedef _GBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _GClos (const _Dom& __e, const valarray& __i) + : _Base (__e, __i) {} }; - template - 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& __i) - : _Base (__a, __i) {} + template + 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& __i) + : _Base (__a, __i) {} }; - // - // indirect_array closure - // - template class _IBase { + // + // indirect_array closure + // + template + class _IBase + { public: - typedef typename _Dom::value_type value_type; + typedef typename _Dom::value_type value_type; - _IBase (const _Dom& __e, const valarray& __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(); } + _IBase (const _Dom& __e, const valarray& __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& _M_index; + const _Dom& _M_expr; + const valarray& _M_index; }; - template struct _IClos<_Expr,_Dom> : _IBase<_Dom> { - typedef _IBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _IClos (const _Dom& __e, const valarray& __i) - : _Base (__e, __i) {} + template + struct _IClos<_Expr, _Dom> + : _IBase<_Dom> + { + typedef _IBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _IClos (const _Dom& __e, const valarray& __i) + : _Base (__e, __i) {} }; - template - struct _IClos<_ValArray,_Tp> : _IBase > { - typedef _IBase > _Base; - typedef _Tp value_type; - - _IClos (const valarray<_Tp>& __a, const valarray& __i) - : _Base (__a, __i) {} + template + struct _IClos<_ValArray, _Tp> + : _IBase > + { + typedef _IBase > _Base; + typedef _Tp value_type; + + _IClos (const valarray<_Tp>& __a, const valarray& __i) + : _Base (__a, __i) {} }; - + // // class _Expr // @@ -146,17 +175,17 @@ namespace std 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<__negate,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<__bitwise_not, std::_Expr, _Clos>, value_type> + operator~() const; - _Expr<_UnClos<__logical_not,std::_Expr,_Clos>, bool> - operator!() const; + _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool> + operator!() const; size_t size() const; value_type sum() const; @@ -176,41 +205,42 @@ namespace std template inline - _Expr<_Clos,_Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} + _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} template inline const _Clos& - _Expr<_Clos,_Tp>::operator()() const + _Expr<_Clos, _Tp>::operator()() const { return _M_closure; } template inline _Tp - _Expr<_Clos,_Tp>::operator[](size_t __i) const + _Expr<_Clos, _Tp>::operator[](size_t __i) const { return _M_closure[__i]; } template inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[](slice __s) const + _Expr<_Clos, _Tp>::operator[](slice __s) const { return _M_closure[__s]; } 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 inline valarray<_Tp> - _Expr<_Clos,_Tp>::operator[](const valarray& __m) const + _Expr<_Clos, _Tp>::operator[](const valarray& __m) const { return _M_closure[__m]; } 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 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> @@ -235,7 +265,7 @@ namespace std // 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) @@ -260,20 +290,20 @@ namespace std { return __valarray_max(_M_closure); } template - inline _Expr<_UnClos<__logical_not,_Expr,_Dom>, bool> - _Expr<_Dom,_Tp>::operator!() const + inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool> + _Expr<_Dom, _Tp>::operator!() const { - typedef _UnClos<__logical_not,std::_Expr,_Dom> _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 \ + 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)); \ + typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \ } _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) @@ -282,67 +312,70 @@ namespace std #undef _DEFINE_EXPR_UNARY_OPERATOR - #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ template \ - 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())); \ - } \ + 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 \ -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 \ + 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 \ -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 \ + 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 \ -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& __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 \ + 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& __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 \ -inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>,\ - typename __fun<_Name, typename _Dom::value_type>::result_type>\ -operator _Op(const valarray& __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 ())); \ -} + template \ + inline _Expr<_BinClos<_Name, _ValArray, _Expr, \ + typename _Dom::value_type, _Dom>, \ + typename __fun<_Name, typename _Dom::value_type>::result_type> \ + operator _Op(const valarray& __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) @@ -367,20 +400,21 @@ operator _Op(const valarray& __v, \ #define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \ template \ - inline _Expr<_UnClos<__##_Name,_Expr,_Dom>,typename _Dom::value_type>\ - _Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \ + 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 _UnClos<__##_Name,_Expr,_Dom> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__e())); \ + typedef _UnClos<__##_Name, _Expr, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e())); \ } \ \ template \ - inline _Expr<_UnClos<__##_Name,_ValArray,_Tp>,_Tp> \ + inline _Expr<_UnClos<__##_Name, _ValArray, _Tp>, _Tp> \ _Name(const valarray<_Tp>& __v) \ { \ - typedef _UnClos<__##_Name,_ValArray,_Tp> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__v)); \ + typedef _UnClos<__##_Name, _ValArray, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v)); \ } _DEFINE_EXPR_UNARY_FUNCTION(abs) @@ -402,86 +436,86 @@ operator _Op(const valarray& __v, \ #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \ template \ - inline _Expr<_BinClos<__##_Fun,_Expr,_Expr,_Dom1,_Dom2>, \ + inline _Expr<_BinClos<__##_Fun, _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) \ + _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<__##_Fun,_Expr,_Expr,_Dom1,_Dom2> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__e1(), __e2())); \ + typedef _BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \ } \ \ template \ inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom, \ typename _Dom::value_type>, \ typename _Dom::value_type> \ - _Fun(const _Expr<_Dom,typename _Dom::value_type>& __e, \ + _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ const valarray& __v) \ { \ typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure;\ - return _Expr<_Closure,_Tp>(_Closure(__e(), __v)); \ + typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \ } \ \ template \ inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \ - typename _Dom::value_type,_Dom>, \ + typename _Dom::value_type, _Dom>, \ typename _Dom::value_type> \ _Fun(const valarray& __v, \ - const _Expr<_Dom,typename _Dom::value_type>& __e) \ + const _Expr<_Dom, typename _Dom::value_type>& __e) \ { \ typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<__##_Fun,_ValArray,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__v, __e())); \ + typedef _BinClos<__##_Fun, _ValArray, _Expr, _Tp, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \ } \ \ template \ - inline _Expr<_BinClos<__##_Fun,_Expr,_Constant,_Dom, \ + inline _Expr<_BinClos<__##_Fun, _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<__##_Fun,_Expr,_Constant,_Dom,_Tp> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__e(), __t)); \ + typedef _BinClos<__##_Fun, _Expr, _Constant, _Dom, _Tp> _Closure;\ + return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \ } \ \ template \ - inline _Expr<_BinClos<__##_Fun,_Constant,_Expr, \ - typename _Dom::value_type,_Dom>, \ + inline _Expr<_BinClos<__##_Fun, _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) \ + const _Expr<_Dom, typename _Dom::value_type>& __e) \ { \ typedef typename _Dom::value_type _Tp; \ - typedef _BinClos<__##_Fun, _Constant,_Expr,_Tp,_Dom> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__t, __e())); \ + typedef _BinClos<__##_Fun, _Constant, _Expr, _Tp, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \ } \ \ template \ - inline _Expr<_BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \ + inline _Expr<_BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \ _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ { \ - typedef _BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__v, __w)); \ + typedef _BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \ } \ \ template \ - inline _Expr<_BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp>,_Tp> \ + inline _Expr<_BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \ _Fun(const valarray<_Tp>& __v, const _Tp& __t) \ { \ - typedef _BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__v, __t)); \ + typedef _BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \ } \ \ template \ - inline _Expr<_BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp>,_Tp> \ + inline _Expr<_BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \ _Fun(const _Tp& __t, const valarray<_Tp>& __v) \ { \ - typedef _BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp> _Closure; \ - return _Expr<_Closure,_Tp>(_Closure(__t, __v)); \ + typedef _BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ } _DEFINE_EXPR_BINARY_FUNCTION(atan2) @@ -491,7 +525,6 @@ _DEFINE_EXPR_BINARY_FUNCTION(pow) } // std:: - #endif /* _CPP_VALARRAY_AFTER_H */ // Local Variables: diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h index e18e8e8e9e8..a104f7ba752 100644 --- a/libstdc++-v3/include/bits/valarray_array.h +++ b/libstdc++-v3/include/bits/valarray_array.h @@ -79,7 +79,10 @@ namespace std // valarrays aren't required to be exception safe. inline static void _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { while (__b != __e) new(__b++) _Tp(); } + { + while (__b != __e) + new(__b++) _Tp(); + } }; template @@ -88,7 +91,7 @@ namespace std // For fundamental types, it suffices to say 'memset()' inline static void _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) - { std::memset(__b, 0, (__e - __b)*sizeof(_Tp)); } + { std::memset(__b, 0, (__e - __b) * sizeof(_Tp)); } }; template @@ -109,7 +112,10 @@ namespace std // valarrays aren't required to be exception safe. inline static void _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) - { while (__b != __e) new(__b++) _Tp(__t); } + { + while (__b != __e) + new(__b++) _Tp(__t); + } }; template @@ -117,7 +123,10 @@ namespace std { inline static void _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) - { while (__b != __e) *__b++ = __t; } + { + while (__b != __e) + *__b++ = __t; + } }; template @@ -141,7 +150,10 @@ namespace std inline static void _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, _Tp* __restrict__ __o) - { while (__b != __e) new(__o++) _Tp(*__b++); } + { + while (__b != __e) + new(__o++) _Tp(*__b++); + } }; template @@ -170,9 +182,17 @@ namespace std size_t __s, _Tp* __restrict__ __o) { if (__is_fundamental<_Tp>::_M_type) - while (__n--) { *__o++ = *__a; __a += __s; } + while (__n--) + { + *__o++ = *__a; + __a += __s; + } else - while (__n--) { new(__o++) _Tp(*__a); __a += __s; } + while (__n--) + { + new(__o++) _Tp(*__a); + __a += __s; + } } // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]] @@ -183,9 +203,11 @@ namespace std _Tp* __restrict__ __o, size_t __n) { if (__is_fundamental<_Tp>::_M_type) - while (__n--) *__o++ = __a[*__i++]; + while (__n--) + *__o++ = __a[*__i++]; else - while (__n--) new (__o++) _Tp(__a[*__i++]); + while (__n--) + new (__o++) _Tp(__a[*__i++]); } // Do the necessary cleanup when we're done with arrays. @@ -194,28 +216,41 @@ namespace std __valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e) { if (!__is_fundamental<_Tp>::_M_type) - while (__b != __e) { __b->~_Tp(); ++__b; } + while (__b != __e) + { + __b->~_Tp(); + ++__b; + } } // Fill a plain array __a[<__n>] with __t template inline void - __valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t) - { while (__n--) *__a++ = __t; } + __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t) + { + while (__n--) + *__a++ = __t; + } // fill strided array __a[<__n-1 : __s>] with __t template inline void - __valarray_fill (_Tp* __restrict__ __a, size_t __n, - size_t __s, const _Tp& __t) - { for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; } + __valarray_fill(_Tp* __restrict__ __a, size_t __n, + size_t __s, const _Tp& __t) + { + for (size_t __i = 0; __i < __n; ++__i, __a += __s) + *__a = __t; + } // fill indir ect array __a[__i[<__n>]] with __i template inline void __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i, size_t __n, const _Tp& __t) - { for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; } + { + for (size_t __j = 0; __j < __n; ++__j, ++__i) + __a[*__i] = __t; + } // copy plain array __a[<__n>] in __b[<__n>] // For non-fundamental types, it is wrong to say 'memcpy()' @@ -224,7 +259,10 @@ namespace std { inline static void _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) - { while (__n--) *__b++ = *__a++; } + { + while(__n--) + *__b++ = *__a++; + } }; template @@ -239,7 +277,7 @@ namespace std template inline void __valarray_copy(const _Tp* __restrict__ __a, size_t __n, - _Tp* __restrict__ __b) + _Tp* __restrict__ __b) { _Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>:: _S_do_it(__a, __n, __b); @@ -249,15 +287,21 @@ namespace std template inline void __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s, - _Tp* __restrict__ __b) - { for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; } + _Tp* __restrict__ __b) + { + for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s) + *__b = *__a; + } // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>] template inline void __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b, - size_t __n, size_t __s) - { for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; } + size_t __n, size_t __s) + { + for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s) + *__b = *__a; + } // Copy strided array __src[<__n : __s1>] into another // strided array __dst[< : __s2>]. Their sizes must match. @@ -267,7 +311,7 @@ namespace std _Tp* __restrict__ __dst, size_t __s2) { for (size_t __i = 0; __i < __n; ++__i) - __dst[__i * __s2] = __src [ __i * __s1]; + __dst[__i * __s2] = __src[__i * __s1]; } @@ -277,14 +321,20 @@ namespace std __valarray_copy (const _Tp* __restrict__ __a, const size_t* __restrict__ __i, _Tp* __restrict__ __b, size_t __n) - { for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; } + { + for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i) + *__b = __a[*__i]; + } // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]] template inline void __valarray_copy (const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b, const size_t* __restrict__ __i) - { for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; } + { + for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i) + __b[*__i] = *__a; + } // Copy the __n first elements of an indexed array __src[<__i>] into // another indexed array __dst[<__j>]. @@ -310,7 +360,8 @@ namespace std __valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l) { _Tp __r = _Tp(); - while (__f != __l) __r += *__f++; + while (__f != __l) + __r += *__f++; return __r; } @@ -321,7 +372,8 @@ namespace std const _Tp* __restrict__ __l) { _Tp __r = _Tp(1); - while (__f != __l) __r = __r * *__f++; + while (__f != __l) + __r = __r * *__f++; return __r; } @@ -367,12 +419,12 @@ namespace std template struct _Array { - explicit _Array (size_t); - explicit _Array (_Tp* const __restrict__); - explicit _Array (const valarray<_Tp>&); - _Array (const _Tp* __restrict__, size_t); + explicit _Array(size_t); + explicit _Array(_Tp* const __restrict__); + explicit _Array(const valarray<_Tp>&); + _Array(const _Tp* __restrict__, size_t); - _Tp* begin () const; + _Tp* begin() const; _Tp* const __restrict__ _M_data; }; @@ -380,18 +432,18 @@ namespace std template inline void __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) - { std::__valarray_fill (__a._M_data, __n, __t); } + { std::__valarray_fill(__a._M_data, __n, __t); } template inline void - __valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) - { std::__valarray_fill (__a._M_data, __n, __s, __t); } + __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) + { std::__valarray_fill(__a._M_data, __n, __s, __t); } template inline void - __valarray_fill (_Array<_Tp> __a, _Array __i, - size_t __n, const _Tp& __t) - { std::__valarray_fill (__a._M_data, __i._M_data, __n, __t); } + __valarray_fill(_Array<_Tp> __a, _Array __i, + size_t __n, const _Tp& __t) + { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); } // Copy a plain array __a[<__n>] into a play array __b[<>] template @@ -424,14 +476,14 @@ namespace std template inline void __valarray_copy(_Array<_Tp> __a, _Array __i, - _Array<_Tp> __b, size_t __n) + _Array<_Tp> __b, size_t __n) { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); } // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]] template inline void __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, - _Array __i) + _Array __i) { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); } // Copy the __n first elements of an indexed array __src[<__i>] into @@ -447,22 +499,24 @@ namespace std template inline - _Array<_Tp>::_Array (size_t __n) - : _M_data(__valarray_get_storage<_Tp>(__n)) + _Array<_Tp>::_Array(size_t __n) + : _M_data(__valarray_get_storage<_Tp>(__n)) { std::__valarray_default_construct(_M_data, _M_data + __n); } template inline - _Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {} - - template - inline _Array<_Tp>::_Array (const valarray<_Tp>& __v) - : _M_data (__v._M_data) {} + _Array<_Tp>::_Array(_Tp* const __restrict__ __p) + : _M_data (__p) {} template inline - _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s) - : _M_data(__valarray_get_storage<_Tp>(__s)) + _Array<_Tp>::_Array(const valarray<_Tp>& __v) + : _M_data (__v._M_data) {} + + template + inline + _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s) + : _M_data(__valarray_get_storage<_Tp>(__s)) { std::__valarray_copy_construct(__b, __s, _M_data); } template @@ -471,138 +525,152 @@ namespace std { return _M_data; } #define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t) \ -{ \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p) \ - *__p _Op##= __t; \ -} \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) \ + { \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) \ + *__p _Op##= __t; \ + } \ \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \ -{ \ - _Tp* __p = __a._M_data; \ - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q) \ - *__p _Op##= *__q; \ -} \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \ + { \ + _Tp* __p = __a._M_data; \ + for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) \ + *__p _Op##= *__q; \ + } \ \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, \ - const _Expr<_Dom,_Tp>& __e, size_t __n) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i]; \ -} \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, ++__p) \ + *__p _Op##= __e[__i]; \ + } \ \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s, \ - _Array<_Tp> __b) \ -{ \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \ - *__p _Op##= *__q; \ -} \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, size_t __s, \ + _Array<_Tp> __b) \ + { \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; \ + __p += __s, ++__q) \ + *__p _Op##= *__q; \ + } \ \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b, \ - size_t __n, size_t __s) \ -{ \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s) \ - *__p _Op##= *__q; \ -} \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array<_Tp> __b, \ + size_t __n, size_t __s) \ + { \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \ + ++__p, __q += __s) \ + *__p _Op##= *__q; \ + } \ \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __s, \ - const _Expr<_Dom,_Tp>& __e, size_t __n) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i]; \ -} \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __s, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, __p += __s) \ + *__p _Op##= __e[__i]; \ + } \ \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __i, \ - _Array<_Tp> __b, size_t __n) \ -{ \ - _Tp* __q (__b._M_data); \ - for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q) \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __i, \ + _Array<_Tp> __b, size_t __n) \ + { \ + _Tp* __q(__b._M_data); \ + for (size_t* __j = __i._M_data; __j < __i._M_data + __n; \ + ++__j, ++__q) \ __a._M_data[*__j] _Op##= *__q; \ -} \ + } \ \ -template \ -inline void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \ - _Array<_Tp> __b, _Array __i) \ -{ \ - _Tp* __p (__a._M_data); \ - for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \ + _Array<_Tp> __b, _Array __i) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t* __j = __i._M_data; __j<__i._M_data + __n; \ + ++__j, ++__p) \ *__p _Op##= __b._M_data[*__j]; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __i, \ - const _Expr<_Dom, _Tp>& __e, size_t __n) \ -{ \ - size_t* __j (__i._M_data); \ - for (size_t __k=0; __k<__n; ++__k, ++__j) \ - __a._M_data[*__j] _Op##= __e[__k]; \ -} \ - \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __m, \ - _Array<_Tp> __b, size_t __n) \ -{ \ - bool* ok (__m._M_data); \ - _Tp* __p (__a._M_data); \ - for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \ - while (! *ok) { \ - ++ok; \ - ++__p; \ - } \ - *__p _Op##= *__q; \ } \ -} \ \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \ - _Array<_Tp> __b, _Array __m) \ -{ \ - bool* ok (__m._M_data); \ - _Tp* __q (__b._M_data); \ - for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \ - while (! *ok) { \ - ++ok; \ - ++__q; \ - } \ - *__p _Op##= *__q; \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __i, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + size_t* __j(__i._M_data); \ + for (size_t __k = 0; __k<__n; ++__k, ++__j) \ + __a._M_data[*__j] _Op##= __e[__k]; \ } \ -} \ \ -template \ -void \ -_Array_augmented_##_Name (_Array<_Tp> __a, _Array __m, \ - const _Expr<_Dom, _Tp>& __e, size_t __n) \ -{ \ - bool* ok(__m._M_data); \ - _Tp* __p (__a._M_data); \ - for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { \ - while (! *ok) { \ - ++ok; \ - ++__p; \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __m, \ + _Array<_Tp> __b, size_t __n) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __p(__a._M_data); \ + for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; \ + ++__q, ++__ok, ++__p) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__p; \ + } \ + *__p _Op##= *__q; \ } \ - *__p _Op##= __e[__i]; \ } \ -} + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \ + _Array<_Tp> __b, _Array __m) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \ + ++__p, ++__ok, ++__q) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__q; \ + } \ + *__p _Op##= *__q; \ + } \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __m, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__p; \ + } \ + *__p _Op##= __e[__i]; \ + } \ + } _DEFINE_ARRAY_FUNCTION(+, __plus) _DEFINE_ARRAY_FUNCTION(-, __minus) diff --git a/libstdc++-v3/include/bits/valarray_before.h b/libstdc++-v3/include/bits/valarray_before.h index 263ac2f0e22..e1576f07d42 100644 --- a/libstdc++-v3/include/bits/valarray_before.h +++ b/libstdc++-v3/include/bits/valarray_before.h @@ -1,6 +1,7 @@ // The template and inlines for the -*- C++ -*- internal _Meta class. -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 +// 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 @@ -66,85 +67,99 @@ namespace std struct __abs { template - _Tp operator()(const _Tp& __t) const { return abs(__t); } + _Tp operator()(const _Tp& __t) const + { return abs(__t); } }; struct __cos { template - _Tp operator()(const _Tp& __t) const { return cos(__t); } + _Tp operator()(const _Tp& __t) const + { return cos(__t); } }; struct __acos { template - _Tp operator()(const _Tp& __t) const { return acos(__t); } + _Tp operator()(const _Tp& __t) const + { return acos(__t); } }; struct __cosh { template - _Tp operator()(const _Tp& __t) const { return cosh(__t); } + _Tp operator()(const _Tp& __t) const + { return cosh(__t); } }; struct __sin { template - _Tp operator()(const _Tp& __t) const { return sin(__t); } + _Tp operator()(const _Tp& __t) const + { return sin(__t); } }; struct __asin { template - _Tp operator()(const _Tp& __t) const { return asin(__t); } + _Tp operator()(const _Tp& __t) const + { return asin(__t); } }; struct __sinh { template - _Tp operator()(const _Tp& __t) const { return sinh(__t); } + _Tp operator()(const _Tp& __t) const + { return sinh(__t); } }; struct __tan { template - _Tp operator()(const _Tp& __t) const { return tan(__t); } + _Tp operator()(const _Tp& __t) const + { return tan(__t); } }; struct __atan { template - _Tp operator()(const _Tp& __t) const { return atan(__t); } + _Tp operator()(const _Tp& __t) const + { return atan(__t); } }; struct __tanh { template - _Tp operator()(const _Tp& __t) const { return tanh(__t); } + _Tp operator()(const _Tp& __t) const + { return tanh(__t); } }; struct __exp { template - _Tp operator()(const _Tp& __t) const { return exp(__t); } + _Tp operator()(const _Tp& __t) const + { return exp(__t); } }; struct __log { template - _Tp operator()(const _Tp& __t) const { return log(__t); } + _Tp operator()(const _Tp& __t) const + { return log(__t); } }; struct __log10 { template - _Tp operator()(const _Tp& __t) const { return log10(__t); } + _Tp operator()(const _Tp& __t) const + { return log10(__t); } }; struct __sqrt { template - _Tp operator()(const _Tp& __t) const { return sqrt(__t); } + _Tp operator()(const _Tp& __t) const + { return sqrt(__t); } }; // In the past, we used to tailor operator applications semantics @@ -154,19 +169,22 @@ namespace std struct __unary_plus { template - _Tp operator()(const _Tp& __t) const { return +__t; } + _Tp operator()(const _Tp& __t) const + { return +__t; } }; struct __negate { template - _Tp operator()(const _Tp& __t) const { return -__t; } + _Tp operator()(const _Tp& __t) const + { return -__t; } }; struct __bitwise_not { template - _Tp operator()(const _Tp& __t) const { return ~__t; } + _Tp operator()(const _Tp& __t) const + { return ~__t; } }; struct __plus @@ -381,9 +399,9 @@ namespace std typedef bool result_type; }; - // - // Apply function taking a value/const reference closure - // + // + // Apply function taking a value/const reference closure + // template class _FunBase @@ -392,7 +410,7 @@ namespace std typedef typename _Dom::value_type value_type; _FunBase(const _Dom& __e, value_type __f(_Arg)) - : _M_expr(__e), _M_func(__f) {} + : _M_expr(__e), _M_func(__f) {} value_type operator[](size_t __i) const { return _M_func (_M_expr[__i]); } @@ -400,8 +418,8 @@ namespace std size_t size() const { return _M_expr.size ();} private: - const _Dom& _M_expr; - value_type (*_M_func)(_Arg); + const _Dom& _M_expr; + value_type (*_M_func)(_Arg); }; template @@ -424,25 +442,26 @@ namespace std }; template - struct _RefFunClos<_Expr,_Dom> : - _FunBase<_Dom, const typename _Dom::value_type&> + struct _RefFunClos<_Expr, _Dom> + : _FunBase<_Dom, const typename _Dom::value_type&> { typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base; typedef typename _Base::value_type value_type; typedef value_type _Tp; _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&)) - : _Base(__e, __f) {} + : _Base(__e, __f) {} }; template - struct _RefFunClos<_ValArray,_Tp> : _FunBase, const _Tp&> + struct _RefFunClos<_ValArray, _Tp> + : _FunBase, const _Tp&> { typedef _FunBase, const _Tp&> _Base; typedef _Tp value_type; _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&)) - : _Base(__v, __f) {} + : _Base(__v, __f) {} }; // @@ -462,13 +481,14 @@ namespace std { return _Oper()(_M_expr[__i]); } size_t size() const { return _M_expr.size(); } - + private: const _Arg& _M_expr; }; template - struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> + struct _UnClos<_Oper, _Expr, _Dom> + : _UnBase<_Oper, _Dom> { typedef _Dom _Arg; typedef _UnBase<_Oper, _Dom> _Base; @@ -478,7 +498,8 @@ namespace std }; template - struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > + struct _UnClos<_Oper, _ValArray, _Tp> + : _UnBase<_Oper, valarray<_Tp> > { typedef valarray<_Tp> _Arg; typedef _UnBase<_Oper, valarray<_Tp> > _Base; @@ -496,11 +517,11 @@ namespace std class _BinBase { public: - typedef typename _FirstArg::value_type _Vt; - typedef typename __fun<_Oper, _Vt>::result_type value_type; + typedef typename _FirstArg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase(const _FirstArg& __e1, const _SecondArg& __e2) - : _M_expr1(__e1), _M_expr2(__e2) {} + : _M_expr1(__e1), _M_expr2(__e2) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1[__i], _M_expr2[__i]); } @@ -521,7 +542,7 @@ namespace std typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase2(const _Clos& __e, const _Vt& __t) - : _M_expr1(__e), _M_expr2(__t) {} + : _M_expr1(__e), _M_expr2(__t) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1[__i], _M_expr2); } @@ -541,7 +562,7 @@ namespace std typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase1(const _Vt& __t, const _Clos& __e) - : _M_expr1(__t), _M_expr2(__e) {} + : _M_expr1(__t), _M_expr2(__e) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1, _M_expr2[__i]); } @@ -555,52 +576,52 @@ namespace std template struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2> - : _BinBase<_Oper,_Dom1,_Dom2> + : _BinBase<_Oper, _Dom1, _Dom2> { - typedef _BinBase<_Oper,_Dom1,_Dom2> _Base; + typedef _BinBase<_Oper, _Dom1, _Dom2> _Base; typedef typename _Base::value_type value_type; _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {} }; template - struct _BinClos<_Oper,_ValArray,_ValArray,_Tp,_Tp> - : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > + struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp> + : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > { - typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base; + typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base; typedef _Tp value_type; _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w) - : _Base(__v, __w) {} + : _Base(__v, __w) {} }; template - struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type> - : _BinBase<_Oper,_Dom,valarray > + struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type> + : _BinBase<_Oper, _Dom, valarray > { typedef typename _Dom::value_type _Tp; typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2) - : _Base(__e1, __e2) {} + : _Base(__e1, __e2) {} }; template - struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom> - : _BinBase<_Oper,valarray,_Dom> + struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom> + : _BinBase<_Oper, valarray,_Dom> { typedef typename _Dom::value_type _Tp; - typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base; + typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base; typedef typename _Base::value_type value_type; _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2) - : _Base(__e1, __e2) {} + : _Base(__e1, __e2) {} }; template - struct _BinClos<_Oper,_Expr,_Constant,_Dom,typename _Dom::value_type> - : _BinBase2<_Oper,_Dom> + struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type> + : _BinBase2<_Oper, _Dom> { typedef typename _Dom::value_type _Tp; typedef _BinBase2<_Oper,_Dom> _Base; @@ -610,19 +631,19 @@ namespace std }; template - struct _BinClos<_Oper,_Constant,_Expr,typename _Dom::value_type,_Dom> - : _BinBase1<_Oper,_Dom> + struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom> + : _BinBase1<_Oper, _Dom> { typedef typename _Dom::value_type _Tp; - typedef _BinBase1<_Oper,_Dom> _Base; + typedef _BinBase1<_Oper, _Dom> _Base; typedef typename _Base::value_type value_type; _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {} }; template - struct _BinClos<_Oper,_ValArray,_Constant,_Tp,_Tp> - : _BinBase2<_Oper,valarray<_Tp> > + struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp> + : _BinBase2<_Oper, valarray<_Tp> > { typedef _BinBase2<_Oper,valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; @@ -631,69 +652,86 @@ namespace std }; template - struct _BinClos<_Oper,_Constant,_ValArray,_Tp,_Tp> - : _BinBase1<_Oper,valarray<_Tp> > + struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp> + : _BinBase1<_Oper, valarray<_Tp> > { - typedef _BinBase1<_Oper,valarray<_Tp> > _Base; + typedef _BinBase1<_Oper, valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {} }; - // // slice_array closure. // - template class _SBase { + template + class _SBase + { public: - typedef typename _Dom::value_type value_type; - - _SBase (const _Dom& __e, const slice& __s) - : _M_expr (__e), _M_slice (__s) {} - value_type operator[] (size_t __i) const - { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; } - size_t size() const { return _M_slice.size (); } + typedef typename _Dom::value_type value_type; + + _SBase (const _Dom& __e, const slice& __s) + : _M_expr (__e), _M_slice (__s) {} + + value_type + operator[] (size_t __i) const + { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; } + + size_t + size() const + { return _M_slice.size (); } private: - const _Dom& _M_expr; - const slice& _M_slice; + const _Dom& _M_expr; + const slice& _M_slice; }; - template class _SBase<_Array<_Tp> > { + template + class _SBase<_Array<_Tp> > + { public: - typedef _Tp value_type; - - _SBase (_Array<_Tp> __a, const slice& __s) - : _M_array (__a._M_data+__s.start()), _M_size (__s.size()), - _M_stride (__s.stride()) {} - value_type operator[] (size_t __i) const - { return _M_array._M_data[__i * _M_stride]; } - size_t size() const { return _M_size; } + typedef _Tp value_type; + + _SBase (_Array<_Tp> __a, const slice& __s) + : _M_array (__a._M_data+__s.start()), _M_size (__s.size()), + _M_stride (__s.stride()) {} + + value_type + operator[] (size_t __i) const + { return _M_array._M_data[__i * _M_stride]; } + + size_t + size() const + { return _M_size; } private: - const _Array<_Tp> _M_array; - const size_t _M_size; - const size_t _M_stride; + const _Array<_Tp> _M_array; + const size_t _M_size; + const size_t _M_stride; }; - template struct _SClos<_Expr,_Dom> : _SBase<_Dom> { - typedef _SBase<_Dom> _Base; - typedef typename _Base::value_type value_type; - - _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {} + template + struct _SClos<_Expr, _Dom> + : _SBase<_Dom> + { + typedef _SBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {} }; - template - struct _SClos<_ValArray,_Tp> : _SBase<_Array<_Tp> > { - typedef _SBase<_Array<_Tp> > _Base; - typedef _Tp value_type; - - _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {} + template + struct _SClos<_ValArray, _Tp> + : _SBase<_Array<_Tp> > + { + typedef _SBase<_Array<_Tp> > _Base; + typedef _Tp value_type; + + _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {} }; } // std:: - #endif /* _CPP_VALARRAY_BEFORE_H */ // Local Variables: diff --git a/libstdc++-v3/include/std/std_valarray.h b/libstdc++-v3/include/std/std_valarray.h index b893b335415..08ea90971a9 100644 --- a/libstdc++-v3/include/std/std_valarray.h +++ b/libstdc++-v3/include/std/std_valarray.h @@ -147,7 +147,8 @@ namespace std valarray(const indirect_array<_Tp>&); template - valarray(const _Expr<_Dom,_Tp>& __e); + valarray(const _Expr<_Dom, _Tp>& __e); + ~valarray(); // _lib.valarray.assign_ assignment: @@ -211,7 +212,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: /** @@ -237,7 +238,7 @@ namespace std * @param s The source slice. * @return New valarray containing elements in @a s. */ - _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const; + _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const; /** * @brief Return a reference to an array subset. @@ -260,7 +261,7 @@ namespace std * @param s The source slice. * @return Slice_array referencing elements indicated by @a s. */ - _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const; + _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const; /** * @brief Return a reference to an array subset. @@ -286,7 +287,7 @@ namespace std * @param m The valarray bitmask. * @return New valarray containing elements indicated by @a m. */ - valarray<_Tp> operator[](const valarray&) const; + valarray<_Tp> operator[](const valarray&) const; /** * @brief Return a reference to an array subset. @@ -405,26 +406,25 @@ namespace std 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: /// Return the number of elements in array. @@ -444,9 +444,6 @@ namespace std /// Return the maximum element using operator<(). _Tp max() const; - // // FIXME: Extension - // _Tp product () const; - /** * @brief Return a shifted array. * @@ -491,7 +488,7 @@ namespace std * @param func Function of Tp returning Tp to apply. * @return New valarray with transformed elements. */ - _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const; + _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const; /** * @brief Apply a function to the array. @@ -503,7 +500,7 @@ namespace std * @param func Function of const Tp& returning Tp to apply. * @return New valarray with transformed elements. */ - _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const; + _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const; /** * @brief Resize array. @@ -528,7 +525,7 @@ namespace std valarray<_Tp>::operator[](size_t __i) const { __glibcxx_requires_subscript(__i); - return _M_data[__i]; + return _M_data[__i]; } template @@ -536,7 +533,7 @@ namespace std valarray<_Tp>::operator[](size_t __i) { __glibcxx_requires_subscript(__i); - return _M_data[__i]; + return _M_data[__i]; } } // std:: @@ -558,19 +555,19 @@ namespace std template inline valarray<_Tp>::valarray(size_t __n) - : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { std::__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)) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { std::__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)) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0); std::__valarray_copy_construct(__p, __p + __n, _M_data); @@ -579,13 +576,14 @@ namespace std template inline valarray<_Tp>::valarray(const valarray<_Tp>& __v) - : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) - { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } + : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) + { std::__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)) + : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) { std::__valarray_copy (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); @@ -594,8 +592,8 @@ namespace std template inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) - : _M_size(__ga._M_index.size()), - _M_data(__valarray_get_storage<_Tp>(_M_size)) + : _M_size(__ga._M_index.size()), + _M_data(__valarray_get_storage<_Tp>(_M_size)) { std::__valarray_copy (__ga._M_array, _Array(__ga._M_index), @@ -605,7 +603,7 @@ namespace std template inline valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) - : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) + : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) { std::__valarray_copy (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); @@ -614,7 +612,7 @@ namespace std template inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) - : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) + : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) { std::__valarray_copy (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); @@ -623,7 +621,7 @@ namespace std template template inline valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) - : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) + : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) { std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); } template @@ -711,9 +709,7 @@ namespace std template inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) - { - return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); - } + { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); } template inline _Expr<_GClos<_ValArray,_Tp>, _Tp> @@ -784,13 +780,6 @@ namespace std return std::__valarray_sum(_M_data, _M_data + _M_size); } -// template -// inline _Tp -// valarray<_Tp>::product () const -// { -// return __valarray_product(_M_data, _M_data + _M_size); -// } - template inline valarray<_Tp> valarray<_Tp>::shift(int __n) const @@ -805,16 +794,19 @@ namespace std std::__valarray_default_construct(__a, __a + __n); else { - std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); - std::__valarray_default_construct(__a+_M_size-__n, __a + _M_size); + std::__valarray_copy_construct(_M_data + __n, + _M_data + _M_size, __a); + std::__valarray_default_construct(__a + _M_size -__n, + __a + _M_size); } } else // __n < 0: shift right { - std::__valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n); + std::__valarray_copy_construct (_M_data, _M_data + _M_size + __n, + __a - __n); std::__valarray_default_construct(__a, __a - __n); } - return valarray<_Tp> (__a, _M_size); + return valarray<_Tp>(__a, _M_size); } template @@ -827,13 +819,15 @@ namespace std std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a); else if (__n > 0) // cshift left { - std::__valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n); - std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); + std::__valarray_copy_construct(_M_data, _M_data + __n, + __a + _M_size - __n); + std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size, + __a); } else // cshift right { std::__valarray_copy_construct - (_M_data + _M_size+__n, _M_data + _M_size, __a); + (_M_data + _M_size + __n, _M_data + _M_size, __a); std::__valarray_copy_construct (_M_data, _M_data + _M_size+__n, __a - __n); } @@ -862,7 +856,7 @@ namespace std valarray<_Tp>::min() const { _GLIBCXX_DEBUG_ASSERT(_M_size > 0); - return *std::min_element (_M_data, _M_data+_M_size); + return *std::min_element(_M_data, _M_data+_M_size); } template @@ -870,34 +864,34 @@ namespace std valarray<_Tp>::max() const { _GLIBCXX_DEBUG_ASSERT(_M_size > 0); - return *std::max_element (_M_data, _M_data+_M_size); + return *std::max_element(_M_data, _M_data+_M_size); } template - inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> + 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)); + typedef _ValFunClos<_ValArray, _Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure(*this, func)); } template - inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> + 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)); + typedef _RefFunClos<_ValArray, _Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure(*this, func)); } #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ template \ - inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ - valarray<_Tp>::operator _Op() const \ - { \ - typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ - typedef typename __fun<_Name, _Tp>::result_type _Rt; \ - return _Expr<_Closure, _Rt>(_Closure(*this)); \ - } + inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ + valarray<_Tp>::operator _Op() const \ + { \ + 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) @@ -941,7 +935,7 @@ _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right) #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ template template \ inline valarray<_Tp>& \ - valarray<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) \ + valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) \ { \ _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \ return *this; \ @@ -963,35 +957,35 @@ _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ template \ - inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, \ + inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, \ typename __fun<_Name, _Tp>::result_type> \ operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ { \ _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \ - typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ + typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \ typedef typename __fun<_Name, _Tp>::result_type _Rt; \ return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \ } \ \ template \ - inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>, \ - typename __fun<_Name, _Tp>::result_type> \ - operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ - { \ - typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ - typedef typename __fun<_Name, _Tp>::result_type _Rt; \ - return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ - } \ + inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ + { \ + typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ + } \ \ template \ - inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>, \ - typename __fun<_Name, _Tp>::result_type> \ - operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ - { \ - typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \ - typedef typename __fun<_Name, _Tp>::result_type _Rt; \ - return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ - } + inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ + { \ + typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ + } _DEFINE_BINARY_OPERATOR(+, __plus) _DEFINE_BINARY_OPERATOR(-, __minus)