indirect_array.h: Trivial formatting fixes.
2004-08-16 Paolo Carlini <pcarlini@suse.de> * include/bits/indirect_array.h: Trivial formatting fixes. * include/bits/valarray_after.h: Likewise. * include/bits/valarray_array.h: Likewise. * src/valarray-inst.cc: Likewise. From-SVN: r86056
This commit is contained in:
Paolo Carlini
Paolo Carlini
parent
8242fd2d6e
commit
82cb25749b
5 changed files with 361 additions and 354 deletions
|
|
@ -1,3 +1,10 @@
|
|||
2004-08-16 Paolo Carlini <pcarlini@suse.de>
|
||||
|
||||
* include/bits/indirect_array.h: Trivial formatting fixes.
|
||||
* include/bits/valarray_after.h: Likewise.
|
||||
* include/bits/valarray_array.h: Likewise.
|
||||
* src/valarray-inst.cc: Likewise.
|
||||
|
||||
2004-08-15 Paolo Carlini <pcarlini@suse.de>
|
||||
|
||||
* testsuite/27_io/basic_stringstream/rdbuf/char/2832.cc: Remove junk.
|
||||
|
|
|
|||
|
|
@ -46,10 +46,10 @@ namespace std
|
|||
* @brief Reference to arbitrary subset of an array.
|
||||
*
|
||||
* An indirect_array is a reference to the actual elements of an array
|
||||
* specified by an ordered array of indices. The way to get an indirect_array is to
|
||||
* call operator[](valarray<size_t>) on a valarray. The returned
|
||||
* indirect_array then permits carrying operations out on the referenced
|
||||
* subset of elements in the original valarray.
|
||||
* specified by an ordered array of indices. The way to get an
|
||||
* indirect_array is to call operator[](valarray<size_t>) on a valarray.
|
||||
* The returned indirect_array then permits carrying operations out on the
|
||||
* referenced subset of elements in the original valarray.
|
||||
*
|
||||
* For example, if an indirect_array is obtained using the array (4,2,0) as
|
||||
* an argument, and then assigned to an array containing (1,2,3), then the
|
||||
|
|
@ -143,34 +143,35 @@ namespace std
|
|||
: _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
|
||||
_Array<size_t> __i)
|
||||
: _M_sz(__s), _M_index(__i), _M_array(__a) {}
|
||||
inline
|
||||
indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
|
||||
_Array<size_t> __i)
|
||||
: _M_sz(__s), _M_index(__i), _M_array(__a) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>&
|
||||
indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
|
||||
{
|
||||
std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
|
||||
return *this;
|
||||
}
|
||||
inline indirect_array<_Tp>&
|
||||
indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
|
||||
{
|
||||
std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array,
|
||||
_M_index);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator=(const _Tp& __t) const
|
||||
{ std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
|
||||
inline void
|
||||
indirect_array<_Tp>::operator=(const _Tp& __t) const
|
||||
{ std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
|
||||
{ std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
|
||||
inline void
|
||||
indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
|
||||
{ std::__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
|
||||
{ std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }
|
||||
template<class _Dom>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
|
||||
{ std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name) \
|
||||
|
|
|
|||
|
|
@ -127,7 +127,9 @@ namespace std
|
|||
operator[] (size_t __i) const
|
||||
{ return _M_expr[_M_index[__i]]; }
|
||||
|
||||
size_t size() const { return _M_index.size(); }
|
||||
size_t
|
||||
size() const
|
||||
{ return _M_index.size(); }
|
||||
|
||||
private:
|
||||
const _Dom& _M_expr;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2003
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
|
|
@ -58,12 +58,12 @@ namespace std
|
|||
{ return operator new(__n); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*__restrict__
|
||||
__valarray_get_storage(size_t __n)
|
||||
{
|
||||
return static_cast<_Tp*__restrict__>
|
||||
(std::__valarray_get_memory(__n * sizeof(_Tp)));
|
||||
}
|
||||
inline _Tp*__restrict__
|
||||
__valarray_get_storage(size_t __n)
|
||||
{
|
||||
return static_cast<_Tp*__restrict__>
|
||||
(std::__valarray_get_memory(__n * sizeof(_Tp)));
|
||||
}
|
||||
|
||||
// Return memory to the system
|
||||
inline void
|
||||
|
|
@ -73,280 +73,279 @@ namespace std
|
|||
// Turn a raw-memory into an array of _Tp filled with _Tp()
|
||||
// This is required in 'valarray<T> v(n);'
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_default_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// 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();
|
||||
}
|
||||
};
|
||||
struct _Array_default_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// 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();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_default_ctor<_Tp, true>
|
||||
{
|
||||
// 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)); }
|
||||
};
|
||||
struct _Array_default_ctor<_Tp, true>
|
||||
{
|
||||
// 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)); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
_Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e);
|
||||
}
|
||||
inline void
|
||||
__valarray_default_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
_Array_default_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e);
|
||||
}
|
||||
|
||||
// Turn a raw-memory into an array of _Tp filled with __t
|
||||
// This is the required in valarray<T> v(n, t). Also
|
||||
// used in valarray<>::resize().
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_init_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// 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);
|
||||
}
|
||||
};
|
||||
struct _Array_init_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// 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);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_init_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
|
||||
{
|
||||
while (__b != __e)
|
||||
*__b++ = __t;
|
||||
}
|
||||
};
|
||||
struct _Array_init_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e, const _Tp __t)
|
||||
{
|
||||
while (__b != __e)
|
||||
*__b++ = __t;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e,
|
||||
const _Tp __t)
|
||||
{
|
||||
_Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __t);
|
||||
}
|
||||
inline void
|
||||
__valarray_fill_construct(_Tp* __restrict__ __b, _Tp* __restrict__ __e,
|
||||
const _Tp __t)
|
||||
{
|
||||
_Array_init_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __t);
|
||||
}
|
||||
|
||||
//
|
||||
// copy-construct raw array [__o, *) from plain array [__b, __e)
|
||||
// We can't just say 'memcpy()'
|
||||
//
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_copy_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// valarrays aren't required to be exception safe.
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{
|
||||
while (__b != __e)
|
||||
new(__o++) _Tp(*__b++);
|
||||
}
|
||||
};
|
||||
struct _Array_copy_ctor
|
||||
{
|
||||
// Please note that this isn't exception safe. But
|
||||
// valarrays aren't required to be exception safe.
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{
|
||||
while (__b != __e)
|
||||
new(__o++) _Tp(*__b++);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_copy_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{ std::memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
|
||||
};
|
||||
struct _Array_copy_ctor<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{ std::memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct(const _Tp* __restrict__ __b,
|
||||
const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{
|
||||
_Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __o);
|
||||
}
|
||||
inline void
|
||||
__valarray_copy_construct(const _Tp* __restrict__ __b,
|
||||
const _Tp* __restrict__ __e,
|
||||
_Tp* __restrict__ __o)
|
||||
{
|
||||
_Array_copy_ctor<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__b, __e, __o);
|
||||
}
|
||||
|
||||
// copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, _Tp* __restrict__ __o)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--)
|
||||
{
|
||||
*__o++ = *__a;
|
||||
__a += __s;
|
||||
}
|
||||
else
|
||||
while (__n--)
|
||||
{
|
||||
new(__o++) _Tp(*__a);
|
||||
__a += __s;
|
||||
}
|
||||
}
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, _Tp* __restrict__ __o)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--)
|
||||
{
|
||||
*__o++ = *__a;
|
||||
__a += __s;
|
||||
}
|
||||
else
|
||||
while (__n--)
|
||||
{
|
||||
new(__o++) _Tp(*__a);
|
||||
__a += __s;
|
||||
}
|
||||
}
|
||||
|
||||
// copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __o, size_t __n)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--)
|
||||
*__o++ = __a[*__i++];
|
||||
else
|
||||
while (__n--)
|
||||
new (__o++) _Tp(__a[*__i++]);
|
||||
}
|
||||
inline void
|
||||
__valarray_copy_construct (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __o, size_t __n)
|
||||
{
|
||||
if (__is_fundamental<_Tp>::_M_type)
|
||||
while (__n--)
|
||||
*__o++ = __a[*__i++];
|
||||
else
|
||||
while (__n--)
|
||||
new (__o++) _Tp(__a[*__i++]);
|
||||
}
|
||||
|
||||
// Do the necessary cleanup when we're done with arrays.
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
if (!__is_fundamental<_Tp>::_M_type)
|
||||
while (__b != __e)
|
||||
{
|
||||
__b->~_Tp();
|
||||
++__b;
|
||||
}
|
||||
}
|
||||
inline void
|
||||
__valarray_destroy_elements(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
|
||||
{
|
||||
if (!__is_fundamental<_Tp>::_M_type)
|
||||
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;
|
||||
}
|
||||
|
||||
inline void
|
||||
__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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// copy plain array __a[<__n>] in __b[<__n>]
|
||||
// For non-fundamental types, it is wrong to say 'memcpy()'
|
||||
template<typename _Tp, bool>
|
||||
struct _Array_copier
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{
|
||||
while(__n--)
|
||||
*__b++ = *__a++;
|
||||
}
|
||||
};
|
||||
struct _Array_copier
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{
|
||||
while(__n--)
|
||||
*__b++ = *__a++;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
struct _Array_copier<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{ std::memcpy (__b, __a, __n * sizeof (_Tp)); }
|
||||
};
|
||||
struct _Array_copier<_Tp, true>
|
||||
{
|
||||
inline static void
|
||||
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
|
||||
{ std::memcpy (__b, __a, __n * sizeof (_Tp)); }
|
||||
};
|
||||
|
||||
// Copy a plain array __a[<__n>] into a play array __b[<>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b)
|
||||
{
|
||||
_Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__a, __n, __b);
|
||||
}
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b)
|
||||
{
|
||||
_Array_copier<_Tp, __is_fundamental<_Tp>::_M_type>::
|
||||
_S_do_it(__a, __n, __b);
|
||||
}
|
||||
|
||||
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
// Copy strided array __src[<__n : __s1>] into another
|
||||
// strided array __dst[< : __s2>]. Their sizes must match.
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
|
||||
_Tp* __restrict__ __dst, size_t __s2)
|
||||
{
|
||||
for (size_t __i = 0; __i < __n; ++__i)
|
||||
__dst[__i * __s2] = __src[__i * __s1];
|
||||
}
|
||||
|
||||
inline void
|
||||
__valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
|
||||
_Tp* __restrict__ __dst, size_t __s2)
|
||||
{
|
||||
for (size_t __i = 0; __i < __n; ++__i)
|
||||
__dst[__i * __s2] = __src[__i * __s1];
|
||||
}
|
||||
|
||||
// Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__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];
|
||||
}
|
||||
inline void
|
||||
__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];
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
// 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++];
|
||||
}
|
||||
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)
|
||||
|
|
@ -356,59 +355,59 @@ namespace std
|
|||
// algorithm.
|
||||
//
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
__valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp();
|
||||
while (__f != __l)
|
||||
__r += *__f++;
|
||||
return __r;
|
||||
}
|
||||
inline _Tp
|
||||
__valarray_sum(const _Tp* __restrict__ __f, const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp();
|
||||
while (__f != __l)
|
||||
__r += *__f++;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Compute the product of all elements in range [__f, __l)
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
__valarray_product(const _Tp* __restrict__ __f,
|
||||
const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp(1);
|
||||
while (__f != __l)
|
||||
__r = __r * *__f++;
|
||||
return __r;
|
||||
}
|
||||
inline _Tp
|
||||
__valarray_product(const _Tp* __restrict__ __f,
|
||||
const _Tp* __restrict__ __l)
|
||||
{
|
||||
_Tp __r = _Tp(1);
|
||||
while (__f != __l)
|
||||
__r = __r * *__f++;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Compute the min/max of an array-expression
|
||||
template<typename _Ta>
|
||||
inline typename _Ta::value_type
|
||||
__valarray_min(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t < __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
inline typename _Ta::value_type
|
||||
__valarray_min(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t < __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
template<typename _Ta>
|
||||
inline typename _Ta::value_type
|
||||
__valarray_max(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t > __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
inline typename _Ta::value_type
|
||||
__valarray_max(const _Ta& __a)
|
||||
{
|
||||
size_t __s = __a.size();
|
||||
typedef typename _Ta::value_type _Value_type;
|
||||
_Value_type __r = __s == 0 ? _Value_type() : __a[0];
|
||||
for (size_t __i = 1; __i < __s; ++__i)
|
||||
{
|
||||
_Value_type __t = __a[__i];
|
||||
if (__t > __r)
|
||||
__r = __t;
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
//
|
||||
// Helper class _Array, first layer of valarray abstraction.
|
||||
|
|
@ -417,112 +416,111 @@ 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);
|
||||
|
||||
_Tp* begin() const;
|
||||
|
||||
_Tp* const __restrict__ _M_data;
|
||||
};
|
||||
struct _Array
|
||||
{
|
||||
explicit _Array(size_t);
|
||||
explicit _Array(_Tp* const __restrict__);
|
||||
explicit _Array(const valarray<_Tp>&);
|
||||
_Array(const _Tp* __restrict__, size_t);
|
||||
|
||||
_Tp* begin() const;
|
||||
|
||||
_Tp* const __restrict__ _M_data;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
|
||||
{ std::__valarray_fill(__a._M_data, __n, __t); }
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __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); }
|
||||
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); }
|
||||
|
||||
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); }
|
||||
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); }
|
||||
|
||||
// Copy a plain array __a[<__n>] into a play array __b[<>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
|
||||
{ std::__valarray_copy(__a._M_data, __n, __b._M_data); }
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
|
||||
{ std::__valarray_copy(__a._M_data, __n, __b._M_data); }
|
||||
|
||||
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
|
||||
{ std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
|
||||
{ std::__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>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
|
||||
{ __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __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>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
|
||||
_Array<_Tp> __b, size_t __s2)
|
||||
{ std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
|
||||
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
|
||||
_Array<_Tp> __b, size_t __s2)
|
||||
{ std::__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>
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
|
||||
_Array<_Tp> __b, size_t __n)
|
||||
{ std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
|
||||
_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)
|
||||
{ std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
|
||||
_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
|
||||
// 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)
|
||||
{
|
||||
std::__valarray_copy(__src._M_data, __n, __i._M_data,
|
||||
__dst._M_data, __j._M_data);
|
||||
}
|
||||
inline void
|
||||
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
|
||||
_Array<_Tp> __dst, _Array<size_t> __j)
|
||||
{
|
||||
std::__valarray_copy(__src._M_data, __n, __i._M_data,
|
||||
__dst._M_data, __j._M_data);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array(size_t __n)
|
||||
: _M_data(__valarray_get_storage<_Tp>(__n))
|
||||
{ std::__valarray_default_construct(_M_data, _M_data + __n); }
|
||||
inline
|
||||
_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) {}
|
||||
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) {}
|
||||
inline
|
||||
_Array<_Tp>::_Array(const valarray<_Tp>& __v)
|
||||
: _M_data (__v._M_data) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s)
|
||||
: _M_data(__valarray_get_storage<_Tp>(__s))
|
||||
{ std::__valarray_copy_construct(__b, __s, _M_data); }
|
||||
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>
|
||||
inline _Tp*
|
||||
_Array<_Tp>::begin () const
|
||||
{ return _M_data; }
|
||||
inline _Tp*
|
||||
_Array<_Tp>::begin () const
|
||||
{ return _M_data; }
|
||||
|
||||
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
// Explicit instantiation file.
|
||||
|
||||
// Copyright (C) 2001 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2001, 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
|
||||
|
|
@ -48,7 +48,6 @@ namespace std
|
|||
template size_t valarray<size_t>::size() const;
|
||||
template size_t& valarray<size_t>::operator[](size_t);
|
||||
|
||||
|
||||
inline size_t
|
||||
__valarray_product(const valarray<size_t>& __a)
|
||||
{
|
||||
|
|
@ -110,7 +109,7 @@ namespace std
|
|||
|
||||
gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s)
|
||||
: _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s),
|
||||
_M_index(__l.size() == 0 ? 0 : __valarray_product(__l))
|
||||
: _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s),
|
||||
_M_index(__l.size() == 0 ? 0 : __valarray_product(__l))
|
||||
{ __gslice_to_index(__o, __l, __s, _M_index); }
|
||||
} // namespace std
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue