Skip to content

R
riscv-gcc-1
Commit 8164237c by Gabriel Dos Reis Committed by Gabriel Dos Reis
Options

indirect_array.h (indirect_array<>::operator=): Make copy and assignment operator public. 

	* include/bits/indirect_array.h (indirect_array<>::operator=):
	Make copy and assignment operator public.  Implement.  Format.

	* include/bits/valarray_array.h (__valarray_copy): Add overloads
	for copy between index arrays.  Format.

From-SVN: r43483
parent c0eadc6b
Showing with 415 additions and 369 deletions
libstdc++-v3/ChangeLog
2001-06-21 Gabriel Dos Reis <gdr@merlin.codesourcery.com>
* include/bits/indirect_array.h (indirect_array<>::operator=):
Make copy and assignment operator public. Implement. Format.
* include/bits/valarray_array.h (__valarray_copy): Add overloads
for copy between index arrays. Format.
2001-06-19 Benjamin Kosnik <bkoz@redhat.com> 2001-06-19 Benjamin Kosnik <bkoz@redhat.com>
* mknumeric_limits: Add static definitions, format. * mknumeric_limits: Add static definitions, format.
......
libstdc++-v3/include/bits/indirect_array.h
...@@ -34,95 +34,104 @@ ...@@ -34,95 +34,104 @@
#pragma GCC system_header #pragma GCC system_header
namespace std { namespace std
{
template <class _Tp> class indirect_array template <class _Tp>
{ class indirect_array
public: {
typedef _Tp value_type; public:
typedef _Tp value_type;
void operator= (const valarray<_Tp>&) const;
void operator*= (const valarray<_Tp>&) const; // XXX: This is a proposed resolution for DR-253.
void operator/= (const valarray<_Tp>&) const; indirect_array& operator= (const indirect_array&);
void operator%= (const valarray<_Tp>&) const;
void operator+= (const valarray<_Tp>&) const; void operator= (const valarray<_Tp>&) const;
void operator-= (const valarray<_Tp>&) const; void operator*= (const valarray<_Tp>&) const;
void operator^= (const valarray<_Tp>&) const; void operator/= (const valarray<_Tp>&) const;
void operator&= (const valarray<_Tp>&) const; void operator%= (const valarray<_Tp>&) const;
void operator|= (const valarray<_Tp>&) const; void operator+= (const valarray<_Tp>&) const;
void operator<<= (const valarray<_Tp>&) const; void operator-= (const valarray<_Tp>&) const;
void operator>>= (const valarray<_Tp>&) const; void operator^= (const valarray<_Tp>&) const;
void operator= (const _Tp&); void operator&= (const valarray<_Tp>&) const;
// ~indirect_array(); void operator|= (const valarray<_Tp>&) const;
void operator<<= (const valarray<_Tp>&) const;
template<class _Dom> void operator>>= (const valarray<_Tp>&) const;
void operator= (const _Expr<_Dom, _Tp>&) const; void operator= (const _Tp&);
template<class _Dom> // ~indirect_array();
void operator*= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator/= (const _Expr<_Dom, _Tp>&) const; void operator= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator%= (const _Expr<_Dom, _Tp>&) const; void operator*= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator+= (const _Expr<_Dom, _Tp>&) const; void operator/= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator-= (const _Expr<_Dom, _Tp>&) const; void operator%= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator^= (const _Expr<_Dom, _Tp>&) const; void operator+= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator&= (const _Expr<_Dom, _Tp>&) const; void operator-= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator|= (const _Expr<_Dom, _Tp>&) const; void operator^= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator<<= (const _Expr<_Dom, _Tp>&) const; void operator&= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom> template<class _Dom>
void operator>>= (const _Expr<_Dom, _Tp>&) const; void operator|= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
private: void operator<<= (const _Expr<_Dom, _Tp>&) const;
indirect_array (const indirect_array&); template<class _Dom>
indirect_array (_Array<_Tp>, size_t, _Array<size_t>); void operator>>= (const _Expr<_Dom, _Tp>&) const;
friend class valarray<_Tp>; private:
friend class gslice_array<_Tp>; indirect_array (const indirect_array&);
indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
const size_t _M_sz;
const _Array<size_t> _M_index; friend class valarray<_Tp>;
const _Array<_Tp> _M_array; friend class gslice_array<_Tp>;
// not implemented const size_t _M_sz;
indirect_array (); const _Array<size_t> _M_index;
indirect_array& operator= (const indirect_array&); const _Array<_Tp> _M_array;
};
// not implemented
template<typename _Tp> indirect_array ();
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a) };
: _M_sz (__a._M_sz), _M_index (__a._M_index),
_M_array (__a._M_array) {} template<typename _Tp>
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
template<typename _Tp> : _M_sz (__a._M_sz), _M_index (__a._M_index),
inline _M_array (__a._M_array) {}
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
_Array<size_t> __i) template<typename _Tp>
: _M_sz (__s), _M_index (__i), _M_array (__a) {} inline
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
// template<typename _Tp> _Array<size_t> __i)
// inline indirect_array<_Tp>::~indirect_array() {} : _M_sz (__s), _M_index (__i), _M_array (__a) {}
template<typename _Tp> template<typename _Tp>
inline void inline indirect_array<_Tp>&
indirect_array<_Tp>::operator= (const _Tp& __t) indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
{ __valarray_fill(_M_array, _M_index, _M_sz, __t); } {
__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
template<typename _Tp> return *this;
inline void }
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
template<typename _Tp>
template<typename _Tp> inline void
template<class _Dom> indirect_array<_Tp>::operator= (const _Tp& __t)
inline void { __valarray_fill(_M_array, _M_index, _M_sz, __t); }
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); } template<typename _Tp>
inline void
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
template<typename _Tp>
template<class _Dom>
inline void
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
#undef _DEFINE_VALARRAY_OPERATOR #undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(op, name) \ #define _DEFINE_VALARRAY_OPERATOR(op, name) \
......
libstdc++-v3/include/bits/valarray_array.h
...@@ -42,7 +42,6 @@ ...@@ -42,7 +42,6 @@
namespace std namespace std
{ {
// //
// Helper functions on raw pointers // Helper functions on raw pointers
// //
...@@ -53,12 +52,12 @@ namespace std ...@@ -53,12 +52,12 @@ namespace std
{ return operator new(__n); } { return operator new(__n); }
template<typename _Tp> template<typename _Tp>
inline _Tp*__restrict__ inline _Tp*__restrict__
__valarray_get_storage(size_t __n) __valarray_get_storage(size_t __n)
{ {
return static_cast<_Tp*__restrict__> return static_cast<_Tp*__restrict__>
(__valarray_get_memory(__n * sizeof(_Tp))); (__valarray_get_memory(__n * sizeof(_Tp)));
} }
// Return memory to the system // Return memory to the system
inline void inline void
...@@ -68,218 +67,230 @@ namespace std ...@@ -68,218 +67,230 @@ namespace std
// Turn a raw-memory into an array of _Tp filled with _Tp() // Turn a raw-memory into an array of _Tp filled with _Tp()
// This is required in 'valarray<T> v(n);' // This is required in 'valarray<T> v(n);'
template<typename _Tp, bool> template<typename _Tp, bool>
struct _Array_default_ctor struct _Array_default_ctor
{ {
// Please note that this isn't exception safe. But // Please note that this isn't exception safe. But
// valarrays aren't required to be exception safe. // valarrays aren't required to be exception safe.
inline static void inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
{ while (__b != __e) new(__b++) _Tp(); } { while (__b != __e) new(__b++) _Tp(); }
}; };
template<typename _Tp> template<typename _Tp>
struct _Array_default_ctor<_Tp, true> struct _Array_default_ctor<_Tp, true>
{ {
// For fundamental types, it suffices to say 'memset()' // For fundamental types, it suffices to say 'memset()'
inline static void inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) _S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
{ memset(__b, 0, (__e - __b)*sizeof(_Tp)); } { memset(__b, 0, (__e - __b)*sizeof(_Tp)); }
}; };
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e) __valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
{ {
_Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: _Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
_S_do_it(__b, __e); _S_do_it(__b, __e);
} }
// Turn a raw-memory into an array of _Tp filled with __t // Turn a raw-memory into an array of _Tp filled with __t
// This is the required in valarray<T> v(n, t). Also // This is the required in valarray<T> v(n, t). Also
// used in valarray<>::resize(). // used in valarray<>::resize().
template<typename _Tp, bool> template<typename _Tp, bool>
struct _Array_init_ctor struct _Array_init_ctor
{ {
// Please note that this isn't exception safe. But // Please note that this isn't exception safe. But
// valarrays aren't required to be exception safe. // valarrays aren't required to be exception safe.
inline static void inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) _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> template<typename _Tp>
struct _Array_init_ctor<_Tp, true> struct _Array_init_ctor<_Tp, true>
{ {
inline static void inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t) _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> template<typename _Tp>
inline void inline void
__valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e, __valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e,
const _Tp __t) const _Tp __t)
{ {
_Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: _Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
_S_do_it(__b, __e, __t); _S_do_it(__b, __e, __t);
} }
// //
// copy-construct raw array [__o, *) from plain array [__b, __e) // copy-construct raw array [__o, *) from plain array [__b, __e)
// We can't just say 'memcpy()' // We can't just say 'memcpy()'
// //
template<typename _Tp, bool> template<typename _Tp, bool>
struct _Array_copy_ctor struct _Array_copy_ctor
{ {
// Please note that this isn't exception safe. But // Please note that this isn't exception safe. But
// valarrays aren't required to be exception safe. // valarrays aren't required to be exception safe.
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
_Tp* __restrict__ __o) _Tp* __restrict__ __o)
{ while (__b != __e) new(__o++) _Tp(*__b++); } { while (__b != __e) new(__o++) _Tp(*__b++); }
}; };
template<typename _Tp> template<typename _Tp>
struct _Array_copy_ctor<_Tp, true> struct _Array_copy_ctor<_Tp, true>
{ {
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
_Tp* __restrict__ __o) _Tp* __restrict__ __o)
{ memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); } { memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
}; };
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy_construct(const _Tp* __restrict__ __b, __valarray_copy_construct(const _Tp* __restrict__ __b,
const _Tp* __restrict__ __e, const _Tp* __restrict__ __e,
_Tp* __restrict__ __o) _Tp* __restrict__ __o)
{ {
_Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>:: _Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
_S_do_it(__b, __e, __o); _S_do_it(__b, __e, __o);
} }
// copy-construct raw array [__o, *) from strided array __a[<__n : __s>] // copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n, __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
size_t __s, _Tp* __restrict__ __o) size_t __s, _Tp* __restrict__ __o)
{ {
if (__is_fundamental<_Tp>::_M_type) if (__is_fundamental<_Tp>::_M_type)
while (__n--) { *__o++ = *__a; __a += __s; } while (__n--) { *__o++ = *__a; __a += __s; }
else 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>]] // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy_construct (const _Tp* __restrict__ __a, __valarray_copy_construct (const _Tp* __restrict__ __a,
const size_t* __restrict__ __i, const size_t* __restrict__ __i,
_Tp* __restrict__ __o, size_t __n) _Tp* __restrict__ __o, size_t __n)
{ {
if (__is_fundamental<_Tp>::_M_type) if (__is_fundamental<_Tp>::_M_type)
while (__n--) *__o++ = __a[*__i++]; while (__n--) *__o++ = __a[*__i++];
else 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. // Do the necessary cleanup when we're done with arrays.
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e) __valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
{ {
if (!__is_fundamental<_Tp>::_M_type) if (!__is_fundamental<_Tp>::_M_type)
while (__b != __e) { __b->~_Tp(); ++__b; } while (__b != __e) { __b->~_Tp(); ++__b; }
} }
// fill plain array __a[<__n>] with __t // Fill a plain array __a[<__n>] with __t
template<typename _Tp> template<typename _Tp>
void inline void
__valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t) __valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
{ while (__n--) *__a++ = __t; } { while (__n--) *__a++ = __t; }
// fill strided array __a[<__n-1 : __s>] with __t // fill strided array __a[<__n-1 : __s>] with __t
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill (_Tp* __restrict__ __a, size_t __n, __valarray_fill (_Tp* __restrict__ __a, size_t __n,
size_t __s, const _Tp& __t) size_t __s, const _Tp& __t)
{ for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; } { for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; }
// fill indir ect array __a[__i[<__n>]] with __i // fill indir ect array __a[__i[<__n>]] with __i
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i, __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
size_t __n, const _Tp& __t) 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>] // copy plain array __a[<__n>] in __b[<__n>]
// For non-fundamental types, it is wrong to say 'memcpy()' // For non-fundamental types, it is wrong to say 'memcpy()'
template<typename _Tp, bool> template<typename _Tp, bool>
struct _Array_copier struct _Array_copier
{ {
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) _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>
struct _Array_copier<_Tp, true> struct _Array_copier<_Tp, true>
{ {
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
{ memcpy (__b, __a, __n * sizeof (_Tp)); } { memcpy (__b, __a, __n * sizeof (_Tp)); }
}; };
// Copy a plain array __a[<__n>] into a play array __b[<>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (const _Tp* __restrict__ __a, size_t __n, __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
_Tp* __restrict__ __b) _Tp* __restrict__ __b)
{ {
_Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>:: _Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>::
_S_do_it(__a, __n, __b); _S_do_it(__a, __n, __b);
} }
// copy strided array __a[<__n : __s>] in plain __b[<__n>] // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (const _Tp* __restrict__ __a, size_t __n, size_t __s, __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
_Tp* __restrict__ __b) _Tp* __restrict__ __b)
{ for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; } { for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; }
// copy plain __a[<__n>] in strided __b[<__n : __s>] // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (const _Tp* __restrict__ __a, _Tp* __restrict__ __b, __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
size_t __n, size_t __s) size_t __n, size_t __s)
{ for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; } { for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; }
// Copy strided array __src[<__n : __s1>] into another // Copy strided array __src[<__n : __s1>] into another
// strided array __dst[< : __s2>]. Their sizes must match. // strided array __dst[< : __s2>]. Their sizes must match.
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1, __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
_Tp* __restrict__ __dst, size_t __s2) _Tp* __restrict__ __dst, size_t __s2)
{ {
for (size_t __i = 0; __i < __n; ++__i) for (size_t __i = 0; __i < __n; ++__i)
__dst[__i * __s2] = __src [ __i * __s1]; __dst[__i * __s2] = __src [ __i * __s1];
} }
// copy indexed __a[__i[<__n>]] in plain __b[<__n>] // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (const _Tp* __restrict__ __a, __valarray_copy (const _Tp* __restrict__ __a,
const size_t* __restrict__ __i, const size_t* __restrict__ __i,
_Tp* __restrict__ __b, size_t __n) _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 plain __a[<__n>] in indexed __b[__i[<__n>]] // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (const _Tp* __restrict__ __a, size_t __n, __valarray_copy (const _Tp* __restrict__ __a, size_t __n,
_Tp* __restrict__ __b, const size_t* __restrict__ __i) _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>].
template<typename _Tp>
inline void
__valarray_copy(const _Tp* __restrict__ __src, size_t __n,
const size_t* __restrict__ __i,
_Tp* __restrict__ __dst, const size_t* __restrict__ __j)
{
for (size_t __k = 0; __k < __n; ++__k)
__dst[*__j++] = __src[*__i++];
}
// //
// Compute the sum of elements in range [__f, __l) // Compute the sum of elements in range [__f, __l)
...@@ -289,57 +300,57 @@ namespace std ...@@ -289,57 +300,57 @@ namespace std
// algorithm. // algorithm.
// //
template<typename _Tp> template<typename _Tp>
inline _Tp inline _Tp
__valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l) __valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l)
{ {
_Tp __r = _Tp(); _Tp __r = _Tp();
while (__f != __l) __r += *__f++; while (__f != __l) __r += *__f++;
return __r; return __r;
} }
// Compute the product of all elements in range [__f, __l) // Compute the product of all elements in range [__f, __l)
template<typename _Tp> template<typename _Tp>
inline _Tp inline _Tp
__valarray_product(const _Tp* __restrict__ __f, __valarray_product(const _Tp* __restrict__ __f,
const _Tp* __restrict__ __l) const _Tp* __restrict__ __l)
{ {
_Tp __r = _Tp(1); _Tp __r = _Tp(1);
while (__f != __l) __r = __r * *__f++; while (__f != __l) __r = __r * *__f++;
return __r; return __r;
} }
// Compute the min/max of an array-expression // Compute the min/max of an array-expression
template<typename _Ta> template<typename _Ta>
inline typename _Ta::value_type inline typename _Ta::value_type
__valarray_min(const _Ta& __a) __valarray_min(const _Ta& __a)
{ {
size_t __s = __a.size(); size_t __s = __a.size();
typedef typename _Ta::value_type _Value_type; typedef typename _Ta::value_type _Value_type;
_Value_type __r = __s == 0 ? _Value_type() : __a[0]; _Value_type __r = __s == 0 ? _Value_type() : __a[0];
for (size_t __i = 1; __i < __s; ++__i) for (size_t __i = 1; __i < __s; ++__i)
{ {
_Value_type __t = __a[__i]; _Value_type __t = __a[__i];
if (__t < __r) if (__t < __r)
__r = __t; __r = __t;
} }
return __r; return __r;
} }
template<typename _Ta> template<typename _Ta>
inline typename _Ta::value_type inline typename _Ta::value_type
__valarray_max(const _Ta& __a) __valarray_max(const _Ta& __a)
{ {
size_t __s = __a.size(); size_t __s = __a.size();
typedef typename _Ta::value_type _Value_type; typedef typename _Ta::value_type _Value_type;
_Value_type __r = __s == 0 ? _Value_type() : __a[0]; _Value_type __r = __s == 0 ? _Value_type() : __a[0];
for (size_t __i = 1; __i < __s; ++__i) for (size_t __i = 1; __i < __s; ++__i)
{ {
_Value_type __t = __a[__i]; _Value_type __t = __a[__i];
if (__t > __r) if (__t > __r)
__r = __t; __r = __t;
} }
return __r; return __r;
} }
// //
// Helper class _Array, first layer of valarray abstraction. // Helper class _Array, first layer of valarray abstraction.
...@@ -348,92 +359,110 @@ namespace std ...@@ -348,92 +359,110 @@ namespace std
// //
template<typename _Tp> template<typename _Tp>
struct _Array struct _Array
{ {
explicit _Array (size_t); explicit _Array (size_t);
explicit _Array (_Tp* const __restrict__); explicit _Array (_Tp* const __restrict__);
explicit _Array (const valarray<_Tp>&); explicit _Array (const valarray<_Tp>&);
_Array (const _Tp* __restrict__, size_t); _Array (const _Tp* __restrict__, size_t);
_Tp* begin () const; _Tp* begin () const;
_Tp* const __restrict__ _M_data; _Tp* const __restrict__ _M_data;
}; };
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
{ __valarray_fill (__a._M_data, __n, __t); } { __valarray_fill (__a._M_data, __n, __t); }
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) __valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
{ __valarray_fill (__a._M_data, __n, __s, __t); } { __valarray_fill (__a._M_data, __n, __s, __t); }
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i, __valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
size_t __n, const _Tp& __t) size_t __n, const _Tp& __t)
{ __valarray_fill (__a._M_data, __i._M_data, __n, __t); } { __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 inline void
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
{ __valarray_copy (__a._M_data, __n, __b._M_data); } { __valarray_copy(__a._M_data, __n, __b._M_data); }
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
{ __valarray_copy(__a._M_data, __n, __s, __b._M_data); } { __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
// Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
{ __valarray_copy (__a._M_data, __b._M_data, __n, __s); } { __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
// Copy strided array __src[<__n : __s1>] into another
// strided array __dst[< : __s2>]. Their sizes must match.
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1, __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
_Array<_Tp> __b, size_t __s2) _Array<_Tp> __b, size_t __s2)
{ __valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); } { __valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
// Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy (_Array<_Tp> __a, _Array<size_t> __i, __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
_Array<_Tp> __b, size_t __n) _Array<_Tp> __b, size_t __n)
{ __valarray_copy (__a._M_data, __i._M_data, __b._M_data, __n); } { __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> template<typename _Tp>
inline void inline void
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
_Array<size_t> __i) _Array<size_t> __i)
{ __valarray_copy (__a._M_data, __n, __b._M_data, __i._M_data); } { __valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
// Copy the __n first elements of an indexed array __src[<__i>] into
// another indexed array __dst[<__j>].
template<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
_Array<_Tp> __dst, _Array<size_t> __j)
{
__valarray_copy(__src._M_data, __n, __i._M_data,
__dst._M_data, __j._M_data);
}
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array (size_t __n) _Array<_Tp>::_Array (size_t __n)
: _M_data(__valarray_get_storage<_Tp>(__n)) : _M_data(__valarray_get_storage<_Tp>(__n))
{ __valarray_default_construct(_M_data, _M_data + __n); } { __valarray_default_construct(_M_data, _M_data + __n); }
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {} _Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
template<typename _Tp> template<typename _Tp>
inline _Array<_Tp>::_Array (const valarray<_Tp>& __v) inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
: _M_data (__v._M_data) {} : _M_data (__v._M_data) {}
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s) _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
: _M_data(__valarray_get_storage<_Tp>(__s)) : _M_data(__valarray_get_storage<_Tp>(__s))
{ __valarray_copy_construct(__b, __s, _M_data); } { __valarray_copy_construct(__b, __s, _M_data); }
template<typename _Tp> template<typename _Tp>
inline _Tp* inline _Tp*
_Array<_Tp>::begin () const _Array<_Tp>::begin () const
{ return _M_data; } { return _M_data; }
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \ #define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
template<typename _Tp> \ template<typename _Tp> \
...@@ -569,16 +598,16 @@ _Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \ ...@@ -569,16 +598,16 @@ _Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
} \ } \
} }
_DEFINE_ARRAY_FUNCTION(+, plus) _DEFINE_ARRAY_FUNCTION(+, plus)
_DEFINE_ARRAY_FUNCTION(-, minus) _DEFINE_ARRAY_FUNCTION(-, minus)
_DEFINE_ARRAY_FUNCTION(*, multiplies) _DEFINE_ARRAY_FUNCTION(*, multiplies)
_DEFINE_ARRAY_FUNCTION(/, divides) _DEFINE_ARRAY_FUNCTION(/, divides)
_DEFINE_ARRAY_FUNCTION(%, modulus) _DEFINE_ARRAY_FUNCTION(%, modulus)
_DEFINE_ARRAY_FUNCTION(^, xor) _DEFINE_ARRAY_FUNCTION(^, xor)
_DEFINE_ARRAY_FUNCTION(|, or) _DEFINE_ARRAY_FUNCTION(|, or)
_DEFINE_ARRAY_FUNCTION(&, and) _DEFINE_ARRAY_FUNCTION(&, and)
_DEFINE_ARRAY_FUNCTION(<<, shift_left) _DEFINE_ARRAY_FUNCTION(<<, shift_left)
_DEFINE_ARRAY_FUNCTION(>>, shift_right) _DEFINE_ARRAY_FUNCTION(>>, shift_right)
#undef _DEFINE_VALARRAY_FUNCTION #undef _DEFINE_VALARRAY_FUNCTION
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment