OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gslice.h: Trivial formatting fixes. 

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.

From-SVN: r84312
This commit is contained in:
Paolo Carlini 2004-07-08 20:48:04 +00:00 committed by Paolo Carlini
parent d222b827dc
commit b714a4192e
10 changed files with 798 additions and 648 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,15 @@
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

181
libstdc++-v3/include/bits/gslice.h
View File

@ -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<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;
}
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:

30
libstdc++-v3/include/bits/gslice_array.h
View File

@ -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<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;
@ -137,13 +137,11 @@ namespace std {
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)
@ -186,7 +184,7 @@ namespace std {
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> \

1
libstdc++-v3/include/bits/indirect_array.h
View File

@ -156,7 +156,6 @@ namespace std
return *this;
}
template<typename _Tp>
inline void
indirect_array<_Tp>::operator=(const _Tp& __t) const

7
libstdc++-v3/include/bits/mask_array.h
View File

@ -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<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) {}

28
libstdc++-v3/include/bits/slice_array.h
View File

@ -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<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

395
libstdc++-v3/include/bits/valarray_after.h
View File

@ -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 _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
//
@ -146,17 +175,17 @@ namespace std
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;
@ -176,41 +205,42 @@ namespace std
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>
@ -235,7 +265,7 @@ namespace std
// 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)
@ -260,20 +290,20 @@ namespace std
{ 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)
@ -282,67 +312,70 @@ namespace std
#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)
@ -367,20 +400,21 @@ operator _Op(const valarray<typename _Dom::value_type>& __v, \
#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)
@ -402,86 +436,86 @@ operator _Op(const valarray<typename _Dom::value_type>& __v, \
#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)
@ -491,7 +525,6 @@ _DEFINE_EXPR_BINARY_FUNCTION(pow)
} // std::
#endif /* _CPP_VALARRAY_AFTER_H */
// Local Variables:

400
libstdc++-v3/include/bits/valarray_array.h
View File

@ -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<typename _Tp>
@ -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<typename _Tp>
@ -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<typename _Tp>
@ -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<typename _Tp>
@ -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<typename _Tp>
@ -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<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()'
@ -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<typename _Tp>
@ -239,7 +277,7 @@ namespace std
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);
@ -249,15 +287,21 @@ namespace std
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.
@ -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<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>].
@ -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<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;
};
@ -380,18 +432,18 @@ namespace std
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>
@ -424,14 +476,14 @@ namespace std
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
@ -447,22 +499,24 @@ namespace std
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) {}
template<typename _Tp>
inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
: _M_data (__v._M_data) {}
_Array<_Tp>::_Array(_Tp* const __restrict__ __p)
: _M_data (__p) {}
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 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))
{ std::__valarray_copy_construct(__b, __s, _M_data); }
template<typename _Tp>
@ -471,138 +525,152 @@ namespace std
{ 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> \
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; \
} \
} \
\
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; \
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<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> \
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##= __e[__i]; \
} \
}
\
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; \
} \
} \
\
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]; \
} \
}
_DEFINE_ARRAY_FUNCTION(+, __plus)
_DEFINE_ARRAY_FUNCTION(-, __minus)

228
libstdc++-v3/include/bits/valarray_before.h
View File

@ -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<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
@ -154,19 +169,22 @@ namespace std
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
@ -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<typename _Dom, typename _Arg>
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<class _Dom>
@ -424,25 +442,26 @@ namespace std
};
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) {}
};
//
@ -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<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;
@ -478,7 +498,8 @@ namespace std
};
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;
@ -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<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;
@ -610,19 +631,19 @@ namespace std
};
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;
@ -631,69 +652,86 @@ namespace std
};
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:

164
libstdc++-v3/include/std/std_valarray.h
View File

@ -147,7 +147,8 @@ namespace std
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:
@ -211,7 +212,7 @@ namespace std
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:
/**
@ -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<bool>&) const;
valarray<_Tp> operator[](const valarray<bool>&) const;
/**
* @brief Return a reference to an array subset.
@ -405,26 +406,25 @@ namespace std
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.
@ -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<typename _Tp>
@ -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<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);
@ -579,13 +576,14 @@ namespace std
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));
@ -594,8 +592,8 @@ namespace std
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),
@ -605,7 +603,7 @@ namespace std
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);
@ -614,7 +612,7 @@ namespace std
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);
@ -623,7 +621,7 @@ namespace std
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>
@ -711,9 +709,7 @@ namespace std
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>
@ -784,13 +780,6 @@ namespace std
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
@ -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 <class _Tp>
@ -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<typename _Tp>
@ -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<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)
@ -941,7 +935,7 @@ _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#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; \
@ -963,35 +957,35 @@ _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#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)