+2004-07-08 Paolo Carlini <pcarlini@suse.de>
+
+ * 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 <bkoz@redhat.com>
PR c++/16169
#pragma GCC system_header
-namespace std {
-
+namespace std
+{
/**
* @brief Class defining multi-dimensional subset of an array.
*
* 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<size_t>&, const valarray<size_t>&);
+
+ // 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_t> size() const;
+
+ /// Return array of array strides for each dimension.
+ valarray<size_t> 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<size_t>&, const valarray<size_t>&);
-
- // 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_t> size() const;
-
- /// Return array of array strides for each dimension.
- valarray<size_t> stride() const;
-
- private:
- struct _Indexer {
- size_t _M_count;
- size_t _M_start;
- valarray<size_t> _M_size;
- valarray<size_t> _M_stride;
- valarray<size_t> _M_index; // Linear array of referenced indices
- _Indexer(size_t, const valarray<size_t>&,
- const valarray<size_t>&);
- void _M_increment_use() { ++_M_count; }
- size_t _M_decrement_use() { return --_M_count; }
- };
-
- _Indexer* _M_index;
-
- template<typename _Tp> friend class valarray;
+ size_t _M_count;
+ size_t _M_start;
+ valarray<size_t> _M_size;
+ valarray<size_t> _M_stride;
+ valarray<size_t> _M_index; // Linear array of referenced indices
+ _Indexer(size_t, const valarray<size_t>&,
+ const valarray<size_t>&);
+ 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<size_t>
- gslice::size () const
- { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
+ template<typename _Tp> friend class valarray;
+ };
- inline valarray<size_t>
- gslice::stride () const
- { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
+ inline size_t
+ gslice::start () const
+ { return _M_index ? _M_index->_M_start : 0; }
- inline gslice::gslice () : _M_index(0) {}
+ inline valarray<size_t>
+ gslice::size () const
+ { return _M_index ? _M_index->_M_size : valarray<size_t>(); }
- inline
- gslice::gslice(size_t __o, const valarray<size_t>& __l,
- const valarray<size_t>& __s)
- : _M_index(new gslice::_Indexer(__o, __l, __s)) {}
+ inline valarray<size_t>
+ gslice::stride () const
+ { return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
- 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<size_t>& __l,
+ const valarray<size_t>& __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;
+ }
-} // std::
+ 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 */
#pragma GCC system_header
-namespace std {
-
+namespace std
+{
/**
* @brief Reference to multi-dimensional subset of an array.
*
void operator=(const _Tp&) const;
template<class _Dom>
- void operator=(const _Expr<_Dom,_Tp>&) const;
+ void operator=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator*=(const _Expr<_Dom,_Tp>&) const;
+ void operator*=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator/=(const _Expr<_Dom,_Tp>&) const;
+ void operator/=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator%=(const _Expr<_Dom,_Tp>&) const;
+ void operator%=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator+=(const _Expr<_Dom,_Tp>&) const;
+ void operator+=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator-=(const _Expr<_Dom,_Tp>&) const;
+ void operator-=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator^=(const _Expr<_Dom,_Tp>&) const;
+ void operator^=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator&=(const _Expr<_Dom,_Tp>&) const;
+ void operator&=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator|=(const _Expr<_Dom,_Tp>&) const;
+ void operator|=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator<<=(const _Expr<_Dom,_Tp>&) const;
+ void operator<<=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator>>=(const _Expr<_Dom,_Tp>&) const;
+ void operator>>=(const _Expr<_Dom, _Tp>&) const;
private:
_Array<_Tp> _M_array;
const valarray<size_t>& __i)
: _M_array(__a), _M_index(__i) {}
-
template<typename _Tp>
inline
gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
: _M_array(__a._M_array), _M_index(__a._M_index) {}
-
template<typename _Tp>
inline gslice_array<_Tp>&
gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a)
gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \
{ \
_Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index), \
- _Array<_Tp>(__v), __v.size()); \
+ _Array<_Tp>(__v), __v.size()); \
} \
\
template<typename _Tp> \
return *this;
}
-
template<typename _Tp>
inline void
indirect_array<_Tp>::operator=(const _Tp& __t) const
#pragma GCC system_header
-namespace std {
-
+namespace std
+{
/**
* @brief Reference to selected subset of an array.
*
const size_t _M_sz;
const _Array<bool> _M_mask;
- const _Array<_Tp> _M_array;
+ const _Array<_Tp> _M_array;
// not implemented
mask_array();
};
-
template<typename _Tp>
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) {}
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
// ~slice_array ();
template<class _Dom>
- void operator=(const _Expr<_Dom,_Tp>&) const;
+ void operator=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator*=(const _Expr<_Dom,_Tp>&) const;
+ void operator*=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator/=(const _Expr<_Dom,_Tp>&) const;
+ void operator/=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator%=(const _Expr<_Dom,_Tp>&) const;
+ void operator%=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator+=(const _Expr<_Dom,_Tp>&) const;
+ void operator+=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator-=(const _Expr<_Dom,_Tp>&) const;
+ void operator-=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator^=(const _Expr<_Dom,_Tp>&) const;
+ void operator^=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator&=(const _Expr<_Dom,_Tp>&) const;
+ void operator&=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator|=(const _Expr<_Dom,_Tp>&) const;
+ void operator|=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- void operator<<=(const _Expr<_Dom,_Tp>&) const;
+ void operator<<=(const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
- 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
// 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
namespace std
{
-
- //
- // gslice_array closure.
- //
- template<class _Dom> class _GBase {
+ //
+ // gslice_array closure.
+ //
+ template<class _Dom>
+ class _GBase
+ {
public:
- typedef typename _Dom::value_type value_type;
-
- _GBase (const _Dom& __e, const valarray<size_t>& __i)
- : _M_expr (__e), _M_index(__i) {}
- value_type operator[] (size_t __i) const
- { return _M_expr[_M_index[__i]]; }
- size_t size () const { return _M_index.size(); }
+ typedef typename _Dom::value_type value_type;
+
+ _GBase (const _Dom& __e, const valarray<size_t>& __i)
+ : _M_expr (__e), _M_index(__i) {}
+
+ value_type
+ operator[] (size_t __i) const
+ { return _M_expr[_M_index[__i]]; }
+
+ size_t
+ size () const
+ { return _M_index.size(); }
private:
- const _Dom& _M_expr;
- const valarray<size_t>& _M_index;
+ const _Dom& _M_expr;
+ const valarray<size_t>& _M_index;
};
- template<typename _Tp> class _GBase<_Array<_Tp> > {
+ template<typename _Tp>
+ class _GBase<_Array<_Tp> >
+ {
public:
- typedef _Tp value_type;
-
- _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
- : _M_array (__a), _M_index(__i) {}
- value_type operator[] (size_t __i) const
- { return _M_array._M_data[_M_index[__i]]; }
- size_t size () const { return _M_index.size(); }
+ typedef _Tp value_type;
+
+ _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
+ : _M_array (__a), _M_index(__i) {}
+
+ value_type
+ operator[] (size_t __i) const
+ { return _M_array._M_data[_M_index[__i]]; }
+
+ size_t
+ size () const
+ { return _M_index.size(); }
private:
- const _Array<_Tp> _M_array;
- const valarray<size_t>& _M_index;
+ const _Array<_Tp> _M_array;
+ const valarray<size_t>& _M_index;
};
- template<class _Dom> struct _GClos<_Expr,_Dom> : _GBase<_Dom> {
- typedef _GBase<_Dom> _Base;
- typedef typename _Base::value_type value_type;
-
- _GClos (const _Dom& __e, const valarray<size_t>& __i)
- : _Base (__e, __i) {}
+ template<class _Dom>
+ struct _GClos<_Expr, _Dom>
+ : _GBase<_Dom>
+ {
+ typedef _GBase<_Dom> _Base;
+ typedef typename _Base::value_type value_type;
+
+ _GClos (const _Dom& __e, const valarray<size_t>& __i)
+ : _Base (__e, __i) {}
};
- template<typename _Tp>
- struct _GClos<_ValArray,_Tp> : _GBase<_Array<_Tp> > {
- typedef _GBase<_Array<_Tp> > _Base;
- typedef typename _Base::value_type value_type;
-
- _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
- : _Base (__a, __i) {}
+ template<typename _Tp>
+ struct _GClos<_ValArray, _Tp>
+ : _GBase<_Array<_Tp> >
+ {
+ typedef _GBase<_Array<_Tp> > _Base;
+ typedef typename _Base::value_type value_type;
+
+ _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
+ : _Base (__a, __i) {}
};
- //
- // indirect_array closure
- //
- template<class _Dom> class _IBase {
+ //
+ // indirect_array closure
+ //
+ template<class _Dom>
+ class _IBase
+ {
public:
- typedef typename _Dom::value_type value_type;
+ typedef typename _Dom::value_type value_type;
- _IBase (const _Dom& __e, const valarray<size_t>& __i)
- : _M_expr (__e), _M_index (__i) {}
- value_type operator[] (size_t __i) const
- { return _M_expr[_M_index[__i]]; }
- size_t size() const { return _M_index.size(); }
+ _IBase (const _Dom& __e, const valarray<size_t>& __i)
+ : _M_expr (__e), _M_index (__i) {}
+
+ value_type
+ operator[] (size_t __i) const
+ { return _M_expr[_M_index[__i]]; }
+
+ size_t size() const { return _M_index.size(); }
private:
- const _Dom& _M_expr;
- const valarray<size_t>& _M_index;
+ const _Dom& _M_expr;
+ const valarray<size_t>& _M_index;
};
- template<class _Dom> struct _IClos<_Expr,_Dom> : _IBase<_Dom> {
- typedef _IBase<_Dom> _Base;
- typedef typename _Base::value_type value_type;
-
- _IClos (const _Dom& __e, const valarray<size_t>& __i)
- : _Base (__e, __i) {}
+ template<class _Dom>
+ struct _IClos<_Expr, _Dom>
+ : _IBase<_Dom>
+ {
+ typedef _IBase<_Dom> _Base;
+ typedef typename _Base::value_type value_type;
+
+ _IClos (const _Dom& __e, const valarray<size_t>& __i)
+ : _Base (__e, __i) {}
};
- template<typename _Tp>
- struct _IClos<_ValArray,_Tp> : _IBase<valarray<_Tp> > {
- typedef _IBase<valarray<_Tp> > _Base;
- typedef _Tp value_type;
-
- _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
- : _Base (__a, __i) {}
+ template<typename _Tp>
+ struct _IClos<_ValArray, _Tp>
+ : _IBase<valarray<_Tp> >
+ {
+ typedef _IBase<valarray<_Tp> > _Base;
+ typedef _Tp value_type;
+
+ _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
+ : _Base (__a, __i) {}
};
-
+
//
// class _Expr
//
valarray<value_type> operator[](const valarray<bool>&) const;
valarray<value_type> operator[](const valarray<size_t>&) const;
- _Expr<_UnClos<__unary_plus,std::_Expr,_Clos>, value_type>
- operator+() const;
+ _Expr<_UnClos<__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;
template<class _Clos, typename _Tp>
inline
- _Expr<_Clos,_Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
+ _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
template<class _Clos, typename _Tp>
inline const _Clos&
- _Expr<_Clos,_Tp>::operator()() const
+ _Expr<_Clos, _Tp>::operator()() const
{ return _M_closure; }
template<class _Clos, typename _Tp>
inline _Tp
- _Expr<_Clos,_Tp>::operator[](size_t __i) const
+ _Expr<_Clos, _Tp>::operator[](size_t __i) const
{ return _M_closure[__i]; }
template<class _Clos, typename _Tp>
inline valarray<_Tp>
- _Expr<_Clos,_Tp>::operator[](slice __s) const
+ _Expr<_Clos, _Tp>::operator[](slice __s) const
{ return _M_closure[__s]; }
template<class _Clos, typename _Tp>
inline valarray<_Tp>
- _Expr<_Clos,_Tp>::operator[](const gslice& __gs) const
+ _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
{ return _M_closure[__gs]; }
template<class _Clos, typename _Tp>
inline valarray<_Tp>
- _Expr<_Clos,_Tp>::operator[](const valarray<bool>& __m) const
+ _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
{ return _M_closure[__m]; }
template<class _Clos, typename _Tp>
inline valarray<_Tp>
- _Expr<_Clos,_Tp>::operator[](const valarray<size_t>& __i) const
+ _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
{ return _M_closure[__i]; }
template<class _Clos, typename _Tp>
inline size_t
- _Expr<_Clos,_Tp>::size() const { return _M_closure.size (); }
+ _Expr<_Clos, _Tp>::size() const
+ { return _M_closure.size (); }
template<class _Clos, typename _Tp>
inline valarray<_Tp>
// XXX: replace this with a more robust summation algorithm.
template<class _Clos, typename _Tp>
inline _Tp
- _Expr<_Clos,_Tp>::sum() const
+ _Expr<_Clos, _Tp>::sum() const
{
size_t __n = _M_closure.size();
if (__n == 0)
{ return __valarray_max(_M_closure); }
template<class _Dom, typename _Tp>
- 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<class _Dom, typename _Tp> \
- 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)
#undef _DEFINE_EXPR_UNARY_OPERATOR
-
#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
template<class _Dom1, class _Dom2> \
- inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \
- typename __fun<_Name, typename _Dom1::value_type>::result_type>\
- operator _Op(const _Expr<_Dom1,typename _Dom1::value_type>& __v, \
- const _Expr<_Dom2,typename _Dom2::value_type>& __w) \
- { \
- typedef typename _Dom1::value_type _Arg; \
- typedef typename __fun<_Name, _Arg>::result_type _Value; \
- typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \
- return _Expr<_Closure,_Value>(_Closure(__v(), __w())); \
- } \
+ inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \
+ typename __fun<_Name, typename _Dom1::value_type>::result_type> \
+ operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \
+ const _Expr<_Dom2, typename _Dom2::value_type>& __w) \
+ { \
+ typedef typename _Dom1::value_type _Arg; \
+ typedef typename __fun<_Name, _Arg>::result_type _Value; \
+ typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
+ return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \
+ } \
\
-template<class _Dom> \
-inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>,\
- typename __fun<_Name, typename _Dom::value_type>::result_type>\
-operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __v, \
- const typename _Dom::value_type& __t) \
-{ \
- typedef typename _Dom::value_type _Arg; \
- typedef typename __fun<_Name, _Arg>::result_type _Value; \
- typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \
- return _Expr<_Closure,_Value>(_Closure(__v(), __t)); \
-} \
+ template<class _Dom> \
+ inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \
+ typename _Dom::value_type>, \
+ typename __fun<_Name, typename _Dom::value_type>::result_type> \
+ operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \
+ const typename _Dom::value_type& __t) \
+ { \
+ typedef typename _Dom::value_type _Arg; \
+ typedef typename __fun<_Name, _Arg>::result_type _Value; \
+ typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \
+ return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \
+ } \
\
-template<class _Dom> \
-inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>,\
- typename __fun<_Name, typename _Dom::value_type>::result_type>\
-operator _Op(const typename _Dom::value_type& __t, \
- const _Expr<_Dom,typename _Dom::value_type>& __v) \
-{ \
- typedef typename _Dom::value_type _Arg; \
- typedef typename __fun<_Name, _Arg>::result_type _Value; \
- typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \
- return _Expr<_Closure,_Value>(_Closure(__t, __v())); \
-} \
+ template<class _Dom> \
+ inline _Expr<_BinClos<_Name, _Constant, _Expr, \
+ typename _Dom::value_type, _Dom>, \
+ typename __fun<_Name, typename _Dom::value_type>::result_type> \
+ operator _Op(const typename _Dom::value_type& __t, \
+ const _Expr<_Dom, typename _Dom::value_type>& __v) \
+ { \
+ typedef typename _Dom::value_type _Arg; \
+ typedef typename __fun<_Name, _Arg>::result_type _Value; \
+ typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \
+ return _Expr<_Closure, _Value>(_Closure(__t, __v())); \
+ } \
\
-template<class _Dom> \
-inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>,\
- typename __fun<_Name, typename _Dom::value_type>::result_type>\
-operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
- const valarray<typename _Dom::value_type>& __v) \
-{ \
- typedef typename _Dom::value_type _Arg; \
- typedef typename __fun<_Name, _Arg>::result_type _Value; \
- typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Arg> _Closure; \
- return _Expr<_Closure,_Value>(_Closure(__e(), __v)); \
-} \
+ template<class _Dom> \
+ inline _Expr<_BinClos<_Name, _Expr, _ValArray, \
+ _Dom, typename _Dom::value_type>, \
+ typename __fun<_Name, typename _Dom::value_type>::result_type> \
+ operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
+ const valarray<typename _Dom::value_type>& __v) \
+ { \
+ typedef typename _Dom::value_type _Arg; \
+ typedef typename __fun<_Name, _Arg>::result_type _Value; \
+ typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \
+ return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \
+ } \
\
-template<class _Dom> \
-inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>,\
- typename __fun<_Name, typename _Dom::value_type>::result_type>\
-operator _Op(const valarray<typename _Dom::value_type>& __v, \
- const _Expr<_Dom,typename _Dom::value_type>& __e) \
-{ \
- typedef typename _Dom::value_type _Tp; \
- typedef typename __fun<_Name, _Tp>::result_type _Value; \
- typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \
- return _Expr<_Closure,_Value> (_Closure (__v, __e ())); \
-}
+ template<class _Dom> \
+ inline _Expr<_BinClos<_Name, _ValArray, _Expr, \
+ typename _Dom::value_type, _Dom>, \
+ typename __fun<_Name, typename _Dom::value_type>::result_type> \
+ operator _Op(const valarray<typename _Dom::value_type>& __v, \
+ const _Expr<_Dom, typename _Dom::value_type>& __e) \
+ { \
+ typedef typename _Dom::value_type _Tp; \
+ typedef typename __fun<_Name, _Tp>::result_type _Value; \
+ typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \
+ return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \
+ }
_DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
_DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
#define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \
template<class _Dom> \
- 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<typename _Tp> \
- 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)
#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \
template<class _Dom1, class _Dom2> \
- 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<class _Dom> \
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<typename _Dom::value_type>& __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<class _Dom> \
inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \
- typename _Dom::value_type,_Dom>, \
+ typename _Dom::value_type, _Dom>, \
typename _Dom::value_type> \
_Fun(const valarray<typename _Dom::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<class _Dom> \
- 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<class _Dom> \
- 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<typename _Tp> \
- 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<typename _Tp> \
- 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<typename _Tp> \
- 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)
} // std::
-
#endif /* _CPP_VALARRAY_AFTER_H */
// Local Variables:
// 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<typename _Tp>
// 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<typename _Tp>
// 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<typename _Tp>
{
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<typename _Tp>
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<typename _Tp>
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>]]
_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.
__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<typename _Tp>
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<typename _Tp>
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<typename _Tp>
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()'
{
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<typename _Tp>
template<typename _Tp>
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);
template<typename _Tp>
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<typename _Tp>
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.
_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];
}
__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<typename _Tp>
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>].
__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;
}
const _Tp* __restrict__ __l)
{
_Tp __r = _Tp(1);
- while (__f != __l) __r = __r * *__f++;
+ while (__f != __l)
+ __r = __r * *__f++;
return __r;
}
template<typename _Tp>
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;
};
template<typename _Tp>
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<typename _Tp>
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<typename _Tp>
inline void
- __valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
- size_t __n, const _Tp& __t)
- { std::__valarray_fill (__a._M_data, __i._M_data, __n, __t); }
+ __valarray_fill(_Array<_Tp> __a, _Array<size_t> __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<typename _Tp>
template<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __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<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
- _Array<size_t> __i)
+ _Array<size_t> __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
template<typename _Tp>
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<typename _Tp>
inline
- _Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
+ _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
+ : _M_data (__p) {}
template<typename _Tp>
- inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
- : _M_data (__v._M_data) {}
+ inline
+ _Array<_Tp>::_Array(const valarray<_Tp>& __v)
+ : _M_data (__v._M_data) {}
template<typename _Tp>
inline
- _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
- : _M_data(__valarray_get_storage<_Tp>(__s))
+ _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<typename _Tp>
{ return _M_data; }
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
-template<typename _Tp> \
-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<typename _Tp> \
+ 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<typename _Tp> \
-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<typename _Tp> \
+ 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<typename _Tp, class _Dom> \
-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<typename _Tp, class _Dom> \
+ 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<typename _Tp> \
-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<typename _Tp> \
+ 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<typename _Tp> \
-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<typename _Tp> \
+ 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<typename _Tp, class _Dom> \
-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<typename _Tp, class _Dom> \
+ 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<typename _Tp> \
-inline void \
-_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __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<typename _Tp> \
+ inline void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __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<typename _Tp> \
-inline void \
-_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
- _Array<_Tp> __b, _Array<size_t> __i) \
-{ \
- _Tp* __p (__a._M_data); \
- for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \
+ template<typename _Tp> \
+ inline void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \
+ _Array<_Tp> __b, _Array<size_t> __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<typename _Tp, class _Dom> \
-void \
-_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __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<typename _Tp, class _Dom> \
+ void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __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<typename _Tp> \
-void \
-_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __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; \
+ template<typename _Tp> \
+ void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __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##= *__q; \
} \
-} \
\
-template<typename _Tp> \
-void \
-_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
- _Array<_Tp> __b, _Array<bool> __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; \
+ template<typename _Tp> \
+ void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \
+ _Array<_Tp> __b, _Array<bool> __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; \
} \
- *__p _Op##= *__q; \
} \
-} \
\
-template<typename _Tp, class _Dom> \
-void \
-_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __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<typename _Tp, class _Dom> \
+ void \
+ _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __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]; \
} \
- *__p _Op##= __e[__i]; \
- } \
-}
+ }
_DEFINE_ARRAY_FUNCTION(+, __plus)
_DEFINE_ARRAY_FUNCTION(-, __minus)
// 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
struct __abs
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return abs(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return abs(__t); }
};
struct __cos
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return cos(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return cos(__t); }
};
struct __acos
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return acos(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return acos(__t); }
};
struct __cosh
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return cosh(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return cosh(__t); }
};
struct __sin
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return sin(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return sin(__t); }
};
struct __asin
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return asin(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return asin(__t); }
};
struct __sinh
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return sinh(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return sinh(__t); }
};
struct __tan
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return tan(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return tan(__t); }
};
struct __atan
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return atan(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return atan(__t); }
};
struct __tanh
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return tanh(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return tanh(__t); }
};
struct __exp
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return exp(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return exp(__t); }
};
struct __log
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return log(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return log(__t); }
};
struct __log10
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return log10(__t); }
+ _Tp operator()(const _Tp& __t) const
+ { return log10(__t); }
};
struct __sqrt
{
template<typename _Tp>
- _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
struct __unary_plus
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return +__t; }
+ _Tp operator()(const _Tp& __t) const
+ { return +__t; }
};
struct __negate
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return -__t; }
+ _Tp operator()(const _Tp& __t) const
+ { return -__t; }
};
struct __bitwise_not
{
template<typename _Tp>
- _Tp operator()(const _Tp& __t) const { return ~__t; }
+ _Tp operator()(const _Tp& __t) const
+ { return ~__t; }
};
struct __plus
typedef bool result_type;
};
- //
- // Apply function taking a value/const reference closure
- //
+ //
+ // Apply function taking a value/const reference closure
+ //
template<typename _Dom, typename _Arg>
class _FunBase
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]); }
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<class _Dom>
};
template<class _Dom>
- 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<typename _Tp>
- struct _RefFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, const _Tp&>
+ struct _RefFunClos<_ValArray, _Tp>
+ : _FunBase<valarray<_Tp>, const _Tp&>
{
typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
typedef _Tp value_type;
_RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
- : _Base(__v, __f) {}
+ : _Base(__v, __f) {}
};
//
{ return _Oper()(_M_expr[__i]); }
size_t size() const { return _M_expr.size(); }
-
+
private:
const _Arg& _M_expr;
};
template<class _Oper, class _Dom>
- struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom>
+ struct _UnClos<_Oper, _Expr, _Dom>
+ : _UnBase<_Oper, _Dom>
{
typedef _Dom _Arg;
typedef _UnBase<_Oper, _Dom> _Base;
};
template<class _Oper, typename _Tp>
- 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;
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]); }
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); }
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]); }
template<class _Oper, class _Dom1, class _Dom2>
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<class _Oper, typename _Tp>
- 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<class _Oper, class _Dom>
- struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type>
- : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> >
+ struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
+ : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
{
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<class _Oper, class _Dom>
- struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom>
- : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom>
+ struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
+ : _BinBase<_Oper, valarray<typename _Dom::value_type>,_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<class _Oper, class _Dom>
- 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;
};
template<class _Oper, class _Dom>
- 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<class _Oper, typename _Tp>
- 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;
};
template<class _Oper, typename _Tp>
- 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<typename _Dom> class _SBase {
+ template<typename _Dom>
+ 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<typename _Tp> class _SBase<_Array<_Tp> > {
+ template<typename _Tp>
+ 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<class _Dom> 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<class _Dom>
+ 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<typename _Tp>
- 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<typename _Tp>
+ 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:
valarray(const indirect_array<_Tp>&);
template<class _Dom>
- valarray(const _Expr<_Dom,_Tp>& __e);
+ valarray(const _Expr<_Dom, _Tp>& __e);
+
~valarray();
// _lib.valarray.assign_ assignment:
valarray<_Tp>& operator=(const indirect_array<_Tp>&);
template<class _Dom> valarray<_Tp>&
- operator= (const _Expr<_Dom,_Tp>&);
+ operator= (const _Expr<_Dom, _Tp>&);
// _lib.valarray.access_ element access:
/**
* @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.
* @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.
* @param m The valarray bitmask.
* @return New valarray containing elements indicated by @a m.
*/
- valarray<_Tp> operator[](const valarray<bool>&) const;
+ valarray<_Tp> operator[](const valarray<bool>&) const;
/**
* @brief Return a reference to an array subset.
valarray<_Tp>& operator>>=(const valarray<_Tp>&);
template<class _Dom>
- valarray<_Tp>& operator*=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator/=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator%=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator+=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator-=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator^=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator|=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
+ valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
template<class _Dom>
- 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.
/// Return the maximum element using operator<().
_Tp max() const;
- // // FIXME: Extension
- // _Tp product () const;
-
/**
* @brief Return a shifted array.
*
* @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.
* @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.
valarray<_Tp>::operator[](size_t __i) const
{
__glibcxx_requires_subscript(__i);
- return _M_data[__i];
+ return _M_data[__i];
}
template<typename _Tp>
valarray<_Tp>::operator[](size_t __i)
{
__glibcxx_requires_subscript(__i);
- return _M_data[__i];
+ return _M_data[__i];
}
} // std::
template<typename _Tp>
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<typename _Tp>
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<typename _Tp>
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);
template<typename _Tp>
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<typename _Tp>
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));
template<typename _Tp>
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<size_t>(__ga._M_index),
template<typename _Tp>
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);
template<typename _Tp>
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);
template<typename _Tp> template<class _Dom>
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<typename _Tp>
template<typename _Tp>
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<typename _Tp>
inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
return std::__valarray_sum(_M_data, _M_data + _M_size);
}
-// template<typename _Tp>
-// inline _Tp
-// valarray<_Tp>::product () const
-// {
-// return __valarray_product(_M_data, _M_data + _M_size);
-// }
-
template <class _Tp>
inline valarray<_Tp>
valarray<_Tp>::shift(int __n) const
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 <class _Tp>
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);
}
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<typename _Tp>
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<class _Tp>
- 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<class _Tp>
- 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<typename _Tp> \
- 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)
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
template<class _Tp> template<class _Dom> \
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; \
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
template<typename _Tp> \
- 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<typename _Tp> \
- 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<typename _Tp> \
- 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)
projects / gcc.git / commitdiff