mirrors/gcc
0
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-11-30 07:14:09 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

std_complex.h: Fully qualify standard functions with std::, thus avoiding Koenig lookup.

Browse Source 
2003-07-05  Paolo Carlini  <pcarlini@unitus.it>

	* include/std/std_complex.h: Fully qualify standard
	functions with std::, thus avoiding Koenig lookup.
	* include/std/std_memory.h: Likewise.
	* include/std/std_valarray.h: Likewise.

From-SVN: r68982
This commit is contained in:
Paolo Carlini 2003-07-05 22:44:17 +02:00 committed by Paolo Carlini
parent 2c4a71b302
commit eb9a423153
4 changed files with 72 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,10 @@
2003-07-05 Paolo Carlini <pcarlini@unitus.it>
* include/std/std_complex.h: Fully qualify standard
functions with std::, thus avoiding Koenig lookup.
* include/std/std_memory.h: Likewise.
* include/std/std_valarray.h: Likewise.
2003-07-05 Gawain Bolton <gp.bolton@computer.org>
* include/bits/stl_tree.h: _Rb_tree_rebalance(): Add local

48
libstdc++-v3/include/std/std_complex.h
View File

@ -243,7 +243,7 @@ namespace std
complex<_Tp>::operator/=(const complex<_Up>& __z)
{
const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
const _Tp __n = norm(__z);
const _Tp __n = std::norm(__z);
_M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
_M_real = __r / __n;
return *this;
@ -411,18 +411,18 @@ namespace std
{
_Tp __x = __z.real();
_Tp __y = __z.imag();
const _Tp __s = std::max(abs(__x), abs(__y));
const _Tp __s = std::max(std::abs(__x), std::abs(__y));
if (__s == _Tp()) // well ...
return __s;
__x /= __s;
__y /= __s;
return __s * sqrt(__x * __x + __y * __y);
return __s * std::sqrt(__x * __x + __y * __y);
}
template<typename _Tp>
inline _Tp
arg(const complex<_Tp>& __z)
{ return atan2(__z.imag(), __z.real()); }
{ return std::atan2(__z.imag(), __z.real()); }
// 26.2.7/5: norm(__z) returns the squared magintude of __z.
// As defined, norm() is -not- a norm is the common mathematical
@ -447,7 +447,7 @@ namespace std
template<typename _Tp>
static inline _Tp _S_do_it(const complex<_Tp>& __z)
{
_Tp __res = abs(__z);
_Tp __res = std::abs(__z);
return __res * __res;
}
};
@ -462,7 +462,7 @@ namespace std
template<typename _Tp>
inline complex<_Tp>
polar(const _Tp& __rho, const _Tp& __theta)
{ return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
{ return complex<_Tp>(__rho * std::cos(__theta), __rho * std::sin(__theta)); }
template<typename _Tp>
inline complex<_Tp>
@ -476,7 +476,7 @@ namespace std
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
return complex<_Tp>(std::cos(__x) * std::cosh(__y), -std::sin(__x) * std::sinh(__y));
}
template<typename _Tp>
@ -485,23 +485,23 @@ namespace std
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
return complex<_Tp>(std::cosh(__x) * std::cos(__y), std::sinh(__x) * std::sin(__y));
}
template<typename _Tp>
inline complex<_Tp>
exp(const complex<_Tp>& __z)
{ return polar(exp(__z.real()), __z.imag()); }
{ return std::polar(std::exp(__z.real()), __z.imag()); }
template<typename _Tp>
inline complex<_Tp>
log(const complex<_Tp>& __z)
{ return complex<_Tp>(log(abs(__z)), arg(__z)); }
{ return complex<_Tp>(std::log(std::abs(__z)), std::arg(__z)); }
template<typename _Tp>
inline complex<_Tp>
log10(const complex<_Tp>& __z)
{ return log(__z) / log(_Tp(10.0)); }
{ return std::log(__z) / std::log(_Tp(10.0)); }
template<typename _Tp>
inline complex<_Tp>
@ -509,7 +509,7 @@ namespace std
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
return complex<_Tp>(std::sin(__x) * std::cosh(__y), std::cos(__x) * std::sinh(__y));
}
template<typename _Tp>
@ -518,7 +518,7 @@ namespace std
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
return complex<_Tp>(std::sinh(__x) * std::cos(__y), std::cosh(__x) * std::sin(__y));
}
template<typename _Tp>
@ -530,16 +530,16 @@ namespace std
if (__x == _Tp())
{
_Tp __t = sqrt(abs(__y) / 2);
_Tp __t = std::sqrt(std::abs(__y) / 2);
return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
}
else
{
_Tp __t = sqrt(2 * (abs(__z) + abs(__x)));
_Tp __t = std::sqrt(2 * (std::abs(__z) + std::abs(__x)));
_Tp __u = __t / 2;
return __x > _Tp()
? complex<_Tp>(__u, __y / __t)
: complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
: complex<_Tp>(std::abs(__y) / __t, __y < _Tp() ? -__u : __u);
}
}
@ -547,21 +547,21 @@ namespace std
inline complex<_Tp>
tan(const complex<_Tp>& __z)
{
return sin(__z) / cos(__z);
return std::sin(__z) / std::cos(__z);
}
template<typename _Tp>
inline complex<_Tp>
tanh(const complex<_Tp>& __z)
{
return sinh(__z) / cosh(__z);
return std::sinh(__z) / std::cosh(__z);
}
template<typename _Tp>
inline complex<_Tp>
pow(const complex<_Tp>& __z, int __n)
{
return __pow_helper(__z, __n);
return std::__pow_helper(__z, __n);
}
template<typename _Tp>
@ -569,17 +569,17 @@ namespace std
pow(const complex<_Tp>& __x, const _Tp& __y)
{
if (__x.imag() == _Tp())
return pow(__x.real(), __y);
return std::pow(__x.real(), __y);
complex<_Tp> __t = log(__x);
return polar(exp(__y * __t.real()), __y * __t.imag());
complex<_Tp> __t = std::log(__x);
return std::polar(std::exp(__y * __t.real()), __y * __t.imag());
}
template<typename _Tp>
inline complex<_Tp>
pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
return __x == _Tp() ? _Tp() : exp(__y * log(__x));
return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x));
}
template<typename _Tp>
@ -588,7 +588,7 @@ namespace std
{
return __x == _Tp()
? _Tp()
: polar(pow(__x, __y.real()), __y.imag() * log(__x));
: std::polar(std::pow(__x, __y.real()), __y.imag() * std::log(__x));
}
// 26.2.3 complex specializations

2
libstdc++-v3/include/std/std_memory.h
View File

@ -103,7 +103,7 @@ namespace std
template<typename _Tp>
inline pair<_Tp*,ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len)
{ return __get_temporary_buffer(__len, (_Tp*) 0); }
{ return std::__get_temporary_buffer(__len, (_Tp*) 0); }
/**
* @brief The companion to get_temporary_buffer().

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

@ -248,32 +248,32 @@ namespace std
inline
valarray<_Tp>::valarray(size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ __valarray_default_construct(_M_data, _M_data + __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))
{ __valarray_fill_construct(_M_data, _M_data + __n, __t); }
{ 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))
{ __valarray_copy_construct(__p, __p + __n, _M_data); }
{ std::__valarray_copy_construct(__p, __p + __n, _M_data); }
template<typename _Tp>
inline
valarray<_Tp>::valarray(const valarray<_Tp>& __v)
: _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
{ __valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); }
{ 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))
{
__valarray_copy
std::__valarray_copy
(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
}
@ -283,7 +283,7 @@ namespace std
: _M_size(__ga._M_index.size()),
_M_data(__valarray_get_storage<_Tp>(_M_size))
{
__valarray_copy
std::__valarray_copy
(__ga._M_array, _Array<size_t>(__ga._M_index),
_Array<_Tp>(_M_data), _M_size);
}
@ -293,7 +293,7 @@ namespace std
valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
: _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
{
__valarray_copy
std::__valarray_copy
(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
}
@ -302,7 +302,7 @@ namespace std
valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
: _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
{
__valarray_copy
std::__valarray_copy
(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
}
@ -310,21 +310,21 @@ namespace std
inline
valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
: _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
{ __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
{ std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
template<typename _Tp>
inline
valarray<_Tp>::~valarray()
{
__valarray_destroy_elements(_M_data, _M_data + _M_size);
__valarray_release_memory(_M_data);
std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
std::__valarray_release_memory(_M_data);
}
template<typename _Tp>
inline valarray<_Tp>&
valarray<_Tp>::operator=(const valarray<_Tp>& __v)
{
__valarray_copy(__v._M_data, _M_size, _M_data);
std::__valarray_copy(__v._M_data, _M_size, _M_data);
return *this;
}
@ -332,7 +332,7 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const _Tp& __t)
{
__valarray_fill(_M_data, _M_size, __t);
std::__valarray_fill(_M_data, _M_size, __t);
return *this;
}
@ -340,8 +340,8 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
{
__valarray_copy(__sa._M_array, __sa._M_sz,
__sa._M_stride, _Array<_Tp>(_M_data));
std::__valarray_copy(__sa._M_array, __sa._M_sz,
__sa._M_stride, _Array<_Tp>(_M_data));
return *this;
}
@ -349,8 +349,8 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
{
__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
_Array<_Tp>(_M_data), _M_size);
std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
_Array<_Tp>(_M_data), _M_size);
return *this;
}
@ -358,8 +358,8 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
{
__valarray_copy(__ma._M_array, __ma._M_mask,
_Array<_Tp>(_M_data), _M_size);
std::__valarray_copy(__ma._M_array, __ma._M_mask,
_Array<_Tp>(_M_data), _M_size);
return *this;
}
@ -367,8 +367,8 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
{
__valarray_copy(__ia._M_array, __ia._M_index,
_Array<_Tp>(_M_data), _M_size);
std::__valarray_copy(__ia._M_array, __ia._M_index,
_Array<_Tp>(_M_data), _M_size);
return *this;
}
@ -376,8 +376,8 @@ namespace std
inline valarray<_Tp>&
valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
{
__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
return *this;
std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
return *this;
}
template<typename _Tp>
@ -460,7 +460,7 @@ namespace std
inline _Tp
valarray<_Tp>::sum() const
{
return __valarray_sum(_M_data, _M_data + _M_size);
return std::__valarray_sum(_M_data, _M_data + _M_size);
}
// template<typename _Tp>
@ -477,21 +477,21 @@ namespace std
_Tp* const __a = static_cast<_Tp*>
(__builtin_alloca(sizeof(_Tp) * _M_size));
if (__n == 0) // no shift
__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
else if (__n > 0) // __n > 0: shift left
{
if (size_t(__n) > _M_size)
__valarray_default_construct(__a, __a + __n);
std::__valarray_default_construct(__a, __a + __n);
else
{
__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
__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
{
__valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
__valarray_default_construct(__a, __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);
}
@ -503,17 +503,17 @@ namespace std
_Tp* const __a = static_cast<_Tp*>
(__builtin_alloca (sizeof(_Tp) * _M_size));
if (__n == 0) // no cshift
__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
else if (__n > 0) // cshift left
{
__valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
__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
{
__valarray_copy_construct
std::__valarray_copy_construct
(_M_data + _M_size+__n, _M_data + _M_size, __a);
__valarray_copy_construct
std::__valarray_copy_construct
(_M_data, _M_data + _M_size+__n, __a - __n);
}
return valarray<_Tp>(__a, _M_size);
@ -526,28 +526,28 @@ namespace std
// This complication is so to make valarray<valarray<T> > work
// even though it is not required by the standard. Nobody should
// be saying valarray<valarray<T> > anyway. See the specs.
__valarray_destroy_elements(_M_data, _M_data + _M_size);
std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
if (_M_size != __n)
{
__valarray_release_memory(_M_data);
std::__valarray_release_memory(_M_data);
_M_size = __n;
_M_data = __valarray_get_storage<_Tp>(__n);
}
__valarray_fill_construct(_M_data, _M_data + __n, __c);
std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
}
template<typename _Tp>
inline _Tp
valarray<_Tp>::min() const
{
return *min_element (_M_data, _M_data+_M_size);
return *std::min_element (_M_data, _M_data+_M_size);
}
template<typename _Tp>
inline _Tp
valarray<_Tp>::max() const
{
return *max_element (_M_data, _M_data+_M_size);
return *std::max_element (_M_data, _M_data+_M_size);
}
template<class _Tp>