Skip to content

R
riscv-gcc-1
Commit 82cb2574 by Paolo Carlini Committed by Paolo Carlini
Options

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
parent 8242fd2d
Showing with 375 additions and 368 deletions
libstdc++-v3/ChangeLog
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> 2004-08-15 Paolo Carlini <pcarlini@suse.de>
* testsuite/27_io/basic_stringstream/rdbuf/char/2832.cc: Remove junk. * testsuite/27_io/basic_stringstream/rdbuf/char/2832.cc: Remove junk.
......
libstdc++-v3/include/bits/indirect_array.h
...@@ -46,10 +46,10 @@ namespace std ...@@ -46,10 +46,10 @@ namespace std
* @brief Reference to arbitrary subset of an array. * @brief Reference to arbitrary subset of an array.
* *
* An indirect_array is a reference to the actual elements 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 * specified by an ordered array of indices. The way to get an
* call operator[](valarray<size_t>) on a valarray. The returned * indirect_array is to call operator[](valarray<size_t>) on a valarray.
* indirect_array then permits carrying operations out on the referenced * The returned indirect_array then permits carrying operations out on the
* subset of elements in the original valarray. * referenced subset of elements in the original valarray.
* *
* For example, if an indirect_array is obtained using the array (4,2,0) as * 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 * an argument, and then assigned to an array containing (1,2,3), then the
...@@ -143,34 +143,35 @@ namespace std ...@@ -143,34 +143,35 @@ namespace std
: _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {} : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {}
template<typename _Tp> template<typename _Tp>
inline inline
indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s, indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s,
_Array<size_t> __i) _Array<size_t> __i)
: _M_sz(__s), _M_index(__i), _M_array(__a) {} : _M_sz(__s), _M_index(__i), _M_array(__a) {}
template<typename _Tp> template<typename _Tp>
inline indirect_array<_Tp>& inline indirect_array<_Tp>&
indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a) indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
{ {
std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index); std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array,
return *this; _M_index);
} return *this;
}
template<typename _Tp> template<typename _Tp>
inline void inline void
indirect_array<_Tp>::operator=(const _Tp& __t) const indirect_array<_Tp>::operator=(const _Tp& __t) const
{ std::__valarray_fill(_M_array, _M_index, _M_sz, __t); } { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
template<typename _Tp> template<typename _Tp>
inline void inline void
indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
{ std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); } { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
template<typename _Tp> template<typename _Tp>
template<class _Dom> template<class _Dom>
inline void inline void
indirect_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
{ std::__valarray_copy(__e, _M_sz, _M_array, _M_index); } { std::__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_after.h
...@@ -127,7 +127,9 @@ namespace std ...@@ -127,7 +127,9 @@ namespace std
operator[] (size_t __i) const operator[] (size_t __i) const
{ return _M_expr[_M_index[__i]]; } { return _M_expr[_M_index[__i]]; }
size_t size() const { return _M_index.size(); } size_t
size() const
{ return _M_index.size(); }
private: private:
const _Dom& _M_expr; const _Dom& _M_expr;
......
libstdc++-v3/include/bits/valarray_array.h
// The template and inlines for the -*- C++ -*- internal _Array helper class. // 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. // Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // This file is part of the GNU ISO C++ Library. This library is free
...@@ -58,12 +58,12 @@ namespace std ...@@ -58,12 +58,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__>
(std::__valarray_get_memory(__n * sizeof(_Tp))); (std::__valarray_get_memory(__n * sizeof(_Tp)));
} }
// Return memory to the system // Return memory to the system
inline void inline void
...@@ -73,280 +73,279 @@ namespace std ...@@ -73,280 +73,279 @@ 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) while (__b != __e)
new(__b++) _Tp(); 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)
{ std::memset(__b, 0, (__e - __b) * sizeof(_Tp)); } { std::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) while (__b != __e)
new(__b++) _Tp(__t); 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) while (__b != __e)
*__b++ = __t; *__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) while (__b != __e)
new(__o++) _Tp(*__b++); 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)
{ std::memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); } { std::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--) while (__n--)
{ {
*__o++ = *__a; *__o++ = *__a;
__a += __s; __a += __s;
} }
else else
while (__n--) while (__n--)
{ {
new(__o++) _Tp(*__a); new(__o++) _Tp(*__a);
__a += __s; __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--) while (__n--)
*__o++ = __a[*__i++]; *__o++ = __a[*__i++];
else else
while (__n--) while (__n--)
new (__o++) _Tp(__a[*__i++]); 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) while (__b != __e)
{ {
__b->~_Tp(); __b->~_Tp();
++__b; ++__b;
} }
} }
// Fill a plain array __a[<__n>] with __t // Fill a plain array __a[<__n>] with __t
template<typename _Tp> template<typename _Tp>
inline 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--) while (__n--)
*__a++ = __t; *__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) for (size_t __i = 0; __i < __n; ++__i, __a += __s)
*__a = __t; *__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) for (size_t __j = 0; __j < __n; ++__j, ++__i)
__a[*__i] = __t; __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--) while(__n--)
*__b++ = *__a++; *__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)
{ std::memcpy (__b, __a, __n * sizeof (_Tp)); } { std::memcpy (__b, __a, __n * sizeof (_Tp)); }
}; };
// Copy a plain array __a[<__n>] into a play array __b[<>] // 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) for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s)
*__b = *__a; *__b = *__a;
} }
// Copy a plain array __a[<__n>] into a strided array __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) for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s)
*__b = *__a; *__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 an indexed array __a[__i[<__n>]] in plain array __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) for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i)
*__b = __a[*__i]; *__b = __a[*__i];
} }
// Copy a plain array __a[<__n>] in an indexed array __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) for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i)
__b[*__i] = *__a; __b[*__i] = *__a;
} }
// Copy the __n first elements of an indexed array __src[<__i>] into // Copy the __n first elements of an indexed array __src[<__i>] into
// another indexed array __dst[<__j>]. // another indexed array __dst[<__j>].
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(const _Tp* __restrict__ __src, size_t __n, __valarray_copy(const _Tp* __restrict__ __src, size_t __n,
const size_t* __restrict__ __i, const size_t* __restrict__ __i,
_Tp* __restrict__ __dst, const size_t* __restrict__ __j) _Tp* __restrict__ __dst, const size_t* __restrict__ __j)
{ {
for (size_t __k = 0; __k < __n; ++__k) for (size_t __k = 0; __k < __n; ++__k)
__dst[*__j++] = __src[*__i++]; __dst[*__j++] = __src[*__i++];
} }
// //
// Compute the sum of elements in range [__f, __l) // Compute the sum of elements in range [__f, __l)
...@@ -356,59 +355,59 @@ namespace std ...@@ -356,59 +355,59 @@ 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) while (__f != __l)
__r += *__f++; __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) while (__f != __l)
__r = __r * *__f++; __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.
...@@ -417,112 +416,111 @@ namespace std ...@@ -417,112 +416,111 @@ 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)
{ std::__valarray_fill(__a._M_data, __n, __t); } { std::__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)
{ std::__valarray_fill(__a._M_data, __n, __s, __t); } { std::__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)
{ std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); } { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); }
// Copy a plain array __a[<__n>] into a play array __b[<>] // 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)
{ std::__valarray_copy(__a._M_data, __n, __b._M_data); } { std::__valarray_copy(__a._M_data, __n, __b._M_data); }
// 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(_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)
{ std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); } { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
// Copy a plain array __a[<__n>] into a strided array __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(_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 // 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(_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)
{ std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __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>] // 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)
{ std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __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>]] // 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)
{ std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); } { 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 // Copy the __n first elements of an indexed array __src[<__i>] into
// another indexed array __dst[<__j>]. // another indexed array __dst[<__j>].
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i, __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
_Array<_Tp> __dst, _Array<size_t> __j) _Array<_Tp> __dst, _Array<size_t> __j)
{ {
std::__valarray_copy(__src._M_data, __n, __i._M_data, std::__valarray_copy(__src._M_data, __n, __i._M_data,
__dst._M_data, __j._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))
{ std::__valarray_default_construct(_M_data, _M_data + __n); } { std::__valarray_default_construct(_M_data, _M_data + __n); }
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array(_Tp* const __restrict__ __p) _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
: _M_data (__p) {} : _M_data (__p) {}
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array(const valarray<_Tp>& __v) _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))
{ std::__valarray_copy_construct(__b, __s, _M_data); } { std::__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> \
......
libstdc++-v3/src/valarray-inst.cc
// Explicit instantiation file. // 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 // 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 // software; you can redistribute it and/or modify it under the
...@@ -48,7 +48,6 @@ namespace std ...@@ -48,7 +48,6 @@ namespace std
template size_t valarray<size_t>::size() const; template size_t valarray<size_t>::size() const;
template size_t& valarray<size_t>::operator[](size_t); template size_t& valarray<size_t>::operator[](size_t);
inline size_t inline size_t
__valarray_product(const valarray<size_t>& __a) __valarray_product(const valarray<size_t>& __a)
{ {
...@@ -110,7 +109,7 @@ namespace std ...@@ -110,7 +109,7 @@ namespace std
gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l, gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l,
const valarray<size_t>& __s) const valarray<size_t>& __s)
: _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s), : _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s),
_M_index(__l.size() == 0 ? 0 : __valarray_product(__l)) _M_index(__l.size() == 0 ? 0 : __valarray_product(__l))
{ __gslice_to_index(__o, __l, __s, _M_index); } { __gslice_to_index(__o, __l, __s, _M_index); }
} // namespace std } // namespace std
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