diff options
Diffstat (limited to 'stlport/stl/_valarray.h')
-rw-r--r-- | stlport/stl/_valarray.h | 1684 |
1 files changed, 0 insertions, 1684 deletions
diff --git a/stlport/stl/_valarray.h b/stlport/stl/_valarray.h deleted file mode 100644 index cd9641a..0000000 --- a/stlport/stl/_valarray.h +++ /dev/null @@ -1,1684 +0,0 @@ -/* - * Copyright (c) 1999 - * Silicon Graphics Computer Systems, Inc. - * - * Copyright (c) 1999 - * Boris Fomitchev - * - * This material is provided "as is", with absolutely no warranty expressed - * or implied. Any use is at your own risk. - * - * Permission to use or copy this software for any purpose is hereby granted - * without fee, provided the above notices are retained on all copies. - * Permission to modify the code and to distribute modified code is granted, - * provided the above notices are retained, and a notice that the code was - * modified is included with the above copyright notice. - * - */ - -#ifndef _STLP_VALARRAY_H -#define _STLP_VALARRAY_H - -#ifndef _STLP_INTERNAL_CMATH -# include <stl/_cmath.h> -#endif - -#ifndef _STLP_INTERNAL_NEW -# include <stl/_new.h> -#endif - -#ifndef _STLP_INTERNAL_ALGO_H -# include <stl/_algo.h> -#endif - -#ifndef _STLP_INTERNAL_NUMERIC_H -# include <stl/_numeric.h> -#endif - -#ifndef _STLP_INTERNAL_LIMITS -# include <stl/_limits.h> -#endif - -_STLP_BEGIN_NAMESPACE - -class slice; -class gslice; - -template <class _Tp> class valarray; -typedef valarray<bool> _Valarray_bool; -typedef valarray<size_t> _Valarray_size_t; - -template <class _Tp> class slice_array; -template <class _Tp> class gslice_array; -template <class _Tp> class mask_array; -template <class _Tp> class indirect_array; - -//---------------------------------------------------------------------- -// class valarray - -// Base class to handle memory allocation and deallocation. We can't just -// use vector<>, because vector<bool> would be unsuitable as an internal -// representation for valarray<bool>. - -template <class _Tp> -struct _Valarray_base { - _Tp* _M_first; - size_t _M_size; - - _Valarray_base() : _M_first(0), _M_size(0) {} - _Valarray_base(size_t __n) : _M_first(0), _M_size(0) { _M_allocate(__n); } - ~_Valarray_base() { _M_deallocate(); } - - void _M_allocate(size_t __n) { - if (__n != 0) { - _M_first = __STATIC_CAST(_Tp*, __stl_new(__n * sizeof(_Tp))); - _M_size = __n; - } - else { - _M_first = 0; - _M_size = 0; - } - } - - void _M_deallocate() { - __stl_delete(_M_first); - _M_first = 0; - _M_size = 0; - } -}; - -template <class _Tp> -class valarray : private _Valarray_base<_Tp> -{ - friend class gslice; - -public: - typedef _Tp value_type; - - // Basic constructors - valarray() : _Valarray_base<_Tp>() {} - explicit valarray(size_t __n) : _Valarray_base<_Tp>(__n) - { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); } - valarray(const value_type& __x, size_t __n) : _Valarray_base<_Tp>(__n) - { uninitialized_fill_n(this->_M_first, this->_M_size, __x); } - valarray(const value_type* __p, size_t __n) : _Valarray_base<_Tp>(__n) - { uninitialized_copy(__p, __p + __n, this->_M_first); } - valarray(const valarray<_Tp>& __x) : _Valarray_base<_Tp>(__x._M_size) { - uninitialized_copy(__x._M_first, __x._M_first + __x._M_size, - this->_M_first); - } - - // Constructors from auxiliary array types - valarray(const slice_array<_Tp>&); - valarray(const gslice_array<_Tp>&); - valarray(const mask_array<_Tp>&); - valarray(const indirect_array<_Tp>&); - - // Destructor - ~valarray() { _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); } - - // Extension: constructor that doesn't initialize valarray elements to a - // specific value. This is faster for types such as int and double. -private: - void _M_initialize(const __true_type&) {} - void _M_initialize(const __false_type&) - { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); } - -public: - struct _NoInit {}; - valarray(size_t __n, _NoInit) : _Valarray_base<_Tp>(__n) { - typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Is_Trivial; - _M_initialize(_Is_Trivial()); - } - -public: // Assignment - // Basic assignment. Note that 'x = y' is undefined if x.size() != y.size() - valarray<_Tp>& operator=(const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - if (this != &__x) - copy(__x._M_first, __x._M_first + __x._M_size, this->_M_first); - return *this; - } - - // Scalar assignment - valarray<_Tp>& operator=(const value_type& __x) { - fill_n(this->_M_first, this->_M_size, __x); - return *this; - } - - // Assignment of auxiliary array types - valarray<_Tp>& operator=(const slice_array<_Tp>&); - valarray<_Tp>& operator=(const gslice_array<_Tp>&); - valarray<_Tp>& operator=(const mask_array<_Tp>&); - valarray<_Tp>& operator=(const indirect_array<_Tp>&); - -public: // Element access - value_type operator[](size_t __n) const { - _STLP_ASSERT(__n < this->size()) - return this->_M_first[__n]; - } - value_type& operator[](size_t __n) { - _STLP_ASSERT(__n < this->size()) - return this->_M_first[__n]; - } - size_t size() const { return this->_M_size; } - -public: // Subsetting operations with auxiliary type - valarray<_Tp> operator[](slice) const; - slice_array<_Tp> operator[](slice); - valarray<_Tp> operator[](const gslice&) const; - gslice_array<_Tp> operator[](const gslice&); - valarray<_Tp> operator[](const _Valarray_bool&) const; - mask_array<_Tp> operator[](const _Valarray_bool&); - valarray<_Tp> operator[](const _Valarray_size_t&) const; - indirect_array<_Tp> operator[](const _Valarray_size_t&); - -public: // Unary operators. - valarray<_Tp> operator+() const { return *this; } - - valarray<_Tp> operator-() const { - valarray<_Tp> __tmp(this->size(), _NoInit()); - for (size_t __i = 0; __i < this->size(); ++__i) - __tmp[__i] = -(*this)[__i]; - return __tmp; - } - - valarray<_Tp> operator~() const { - valarray<_Tp> __tmp(this->size(), _NoInit()); - for (size_t __i = 0; __i < this->size(); ++__i) - __tmp[__i] = ~(*this)[__i]; - return __tmp; - } - - _Valarray_bool operator!() const; - -public: // Scalar computed assignment. - valarray<_Tp>& operator*= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] *= __x; - return *this; - } - - valarray<_Tp>& operator/= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] /= __x; - return *this; - } - - valarray<_Tp>& operator%= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] %= __x; - return *this; - } - - valarray<_Tp>& operator+= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] += __x; - return *this; - } - - valarray<_Tp>& operator-= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] -= __x; - return *this; - } - - valarray<_Tp>& operator^= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] ^= __x; - return *this; - } - - valarray<_Tp>& operator&= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] &= __x; - return *this; - } - - valarray<_Tp>& operator|= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] |= __x; - return *this; - } - - valarray<_Tp>& operator<<= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] <<= __x; - return *this; - } - - valarray<_Tp>& operator>>= (const value_type& __x) { - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] >>= __x; - return *this; - } - -public: // Array computed assignment. - valarray<_Tp>& operator*= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] *= __x[__i]; - return *this; - } - - valarray<_Tp>& operator/= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] /= __x[__i]; - return *this; - } - - valarray<_Tp>& operator%= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] %= __x[__i]; - return *this; - } - - valarray<_Tp>& operator+= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] += __x[__i]; - return *this; - } - - valarray<_Tp>& operator-= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] -= __x[__i]; - return *this; - } - - valarray<_Tp>& operator^= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] ^= __x[__i]; - return *this; - } - - valarray<_Tp>& operator&= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] &= __x[__i]; - return *this; - } - - valarray<_Tp>& operator|= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] |= __x[__i]; - return *this; - } - - valarray<_Tp>& operator<<= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] <<= __x[__i]; - return *this; - } - - valarray<_Tp>& operator>>= (const valarray<_Tp>& __x) { - _STLP_ASSERT(__x.size() == this->size()) - for (size_t __i = 0; __i < this->size(); ++__i) - (*this)[__i] >>= __x[__i]; - return *this; - } - -public: // Other member functions. - - // The result is undefined for zero-length arrays - value_type sum() const { - _STLP_ASSERT(this->size() != 0) - return accumulate(this->_M_first + 1, this->_M_first + this->_M_size, - (*this)[0]); - } - - // The result is undefined for zero-length arrays - value_type (min) () const { - _STLP_ASSERT(this->size() != 0) - return *min_element(this->_M_first + 0, this->_M_first + this->_M_size); - } - - value_type (max) () const { - _STLP_ASSERT(this->size() != 0) - return *max_element(this->_M_first + 0, this->_M_first + this->_M_size); - } - - valarray<_Tp> shift(int __n) const; - valarray<_Tp> cshift(int __n) const; - - valarray<_Tp> apply(value_type __f(value_type)) const { - valarray<_Tp> __tmp(this->size()); - transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first, - __f); - return __tmp; - } - valarray<_Tp> apply(value_type __f(const value_type&)) const { - valarray<_Tp> __tmp(this->size()); - transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first, - __f); - return __tmp; - } - - void resize(size_t __n, value_type __x = value_type()) { - _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); - _Valarray_base<_Tp>::_M_deallocate(); - _Valarray_base<_Tp>::_M_allocate(__n); - uninitialized_fill_n(this->_M_first, this->_M_size, __x); - } -}; - -//---------------------------------------------------------------------- -// valarray non-member functions. - -// Binary arithmetic operations between two arrays. Behavior is -// undefined if the two arrays do not have the same length. - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] * __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] / __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] % __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] + __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] - __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] ^ __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] & __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] | __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] << __y[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] >> __y[__i]; - return __tmp; -} - -// Binary arithmetic operations between an array and a scalar. - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] * __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator*(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c * __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] / __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator/(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c / __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] % __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator%(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c % __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] + __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator+(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c + __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] - __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator-(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c - __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] ^ __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator^(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c ^ __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] & __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator&(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c & __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] | __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator|(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c | __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] << __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator<<(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c << __x[__i]; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] >> __c; - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> _STLP_CALL operator>>(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c >> __x[__i]; - return __tmp; -} - -// Binary logical operations between two arrays. Behavior is undefined -// if the two arrays have different lengths. Note that operator== does -// not do what you might at first expect. - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] == __y[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] < __y[__i]; - return __tmp; -} - -#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] != __y[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] > __y[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] <= __y[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] >= __y[__i]; - return __tmp; -} - -#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */ -// fbp : swap ? - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] && __y[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - _STLP_ASSERT(__x.size() == __y.size()) - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] || __y[__i]; - return __tmp; -} - -// Logical operations between an array and a scalar. - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] == __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator==(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c == __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] != __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator!=(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c != __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] < __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c < __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] > __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c > __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] <= __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator<=(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c <= __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] >= __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c >= __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] && __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c && __x[__i]; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __x[__i] || __c; - return __tmp; -} - -template <class _Tp> -inline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x) { - _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = __c || __x[__i]; - return __tmp; -} - -// valarray "transcendentals" (the list includes abs and sqrt, which, -// of course, are not transcendental). - -template <class _Tp> -inline valarray<_Tp> abs(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::abs(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> acos(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::acos(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> asin(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::asin(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> atan(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::atan(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> atan2(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::atan2(__x[__i], __y[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::atan2(__x[__i], __c); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::atan2(__c, __x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> cos(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::cos(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> cosh(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::cosh(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> exp(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::exp(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> log(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::log(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> log10(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::log10(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> pow(const valarray<_Tp>& __x, - const valarray<_Tp>& __y) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::pow(__x[__i], __y[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::pow(__x[__i], __c); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::pow(__c, __x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> sin(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::sin(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> sinh(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::sinh(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::sqrt(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> tan(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::tan(__x[__i]); - return __tmp; -} - -template <class _Tp> -inline valarray<_Tp> tanh(const valarray<_Tp>& __x) { - typedef typename valarray<_Tp>::_NoInit _NoInit; - valarray<_Tp> __tmp(__x.size(), _NoInit()); - for (size_t __i = 0; __i < __x.size(); ++__i) - __tmp[__i] = ::tanh(__x[__i]); - return __tmp; -} - -//---------------------------------------------------------------------- -// slice and slice_array - -class slice { -public: - slice() : _M_start(0), _M_length(0), _M_stride(0) {} - slice(size_t __start, size_t __length, size_t __stride) - : _M_start(__start), _M_length(__length), _M_stride(__stride) - {} - __TRIVIAL_DESTRUCTOR(slice) - - size_t start() const { return _M_start; } - size_t size() const { return _M_length; } - size_t stride() const { return _M_stride; } - -private: - size_t _M_start; - size_t _M_length; - size_t _M_stride; -}; - -template <class _Tp> -class slice_array { - friend class valarray<_Tp>; -public: - typedef _Tp value_type; - - void operator=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] = __x[__i]; - } - - void operator*=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] *= __x[__i]; - } - - void operator/=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] /= __x[__i]; - } - - void operator%=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] %= __x[__i]; - } - - void operator+=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] += __x[__i]; - } - - void operator-=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] -= __x[__i]; - } - - void operator^=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] ^= __x[__i]; - } - - void operator&=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] &= __x[__i]; - } - - void operator|=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] |= __x[__i]; - } - - void operator<<=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] <<= __x[__i]; - } - - void operator>>=(const valarray<value_type>& __x) const { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] >>= __x[__i]; - } - - void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ { - size_t __index = _M_slice.start(); - for (size_t __i = 0; - __i < _M_slice.size(); - ++__i, __index += _M_slice.stride()) - _M_array[__index] = __c; - } - - // C++ Standard defect 253, copy constructor must be public. - slice_array(const slice_array &__x) - : _M_slice(__x._M_slice), _M_array(__x._M_array) - {} - - ~slice_array() {} - -private: - slice_array(const slice& __slice, valarray<_Tp> &__array) - : _M_slice(__slice), _M_array(__array) - {} - - slice _M_slice; - valarray<_Tp>& _M_array; - -private: - // Disable default constructor and assignment - slice_array(); - slice_array& operator=(const slice_array&); -}; - -// valarray member functions dealing with slice and slice_array - -template <class _Tp> -inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x) - : _Valarray_base<_Tp>(__x._M_slice.size()) { - typedef typename __type_traits<_Tp>::has_trivial_default_constructor - _Is_Trivial; - _M_initialize(_Is_Trivial()); - *this = __x; -} - - -template <class _Tp> -inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice) -{ return slice_array<_Tp>(__slice, *this); } - -//---------------------------------------------------------------------- -// gslice and gslice_array - -template <class _Size> -struct _Gslice_Iter_tmpl; - -class gslice { - friend struct _Gslice_Iter_tmpl<size_t>; -public: - gslice() : _M_start(0), _M_lengths(), _M_strides() {} - gslice(size_t __start, - const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides) - : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides) - {} - __TRIVIAL_DESTRUCTOR(gslice) - - size_t start() const { return _M_start; } - _Valarray_size_t size() const { return _M_lengths; } - _Valarray_size_t stride() const { return _M_strides; } - - // Extension: check for an empty gslice. - bool _M_empty() const { return _M_lengths.size() == 0; } - - // Extension: number of indices this gslice represents. (For a degenerate - // gslice, they're not necessarily all distinct.) - size_t _M_size() const { - return !this->_M_empty() - ? accumulate(_M_lengths._M_first + 1, - _M_lengths._M_first + _M_lengths._M_size, - _M_lengths[0], - multiplies<size_t>()) - : 0; - } - -# ifndef __HP_aCC -private: -# endif - - size_t _M_start; - _Valarray_size_t _M_lengths; - _Valarray_size_t _M_strides; -}; - -// This is not an STL iterator. It is constructed from a gslice, and it -// steps through the gslice indices in sequence. See 23.3.6 of the C++ -// standard, paragraphs 2-3, for an explanation of the sequence. At -// each step we get two things: the ordinal (i.e. number of steps taken), -// and the one-dimensional index. - -template <class _Size> -struct _Gslice_Iter_tmpl { - _Gslice_Iter_tmpl(const gslice& __gslice) - : _M_step(0), _M_1d_idx(__gslice.start()), - _M_indices(size_t(0), __gslice._M_lengths.size()), - _M_gslice(__gslice) - {} - - bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; } - - bool _M_incr(); - - _Size _M_step; - _Size _M_1d_idx; - - valarray<_Size> _M_indices; - const gslice& _M_gslice; -}; - -typedef _Gslice_Iter_tmpl<size_t> _Gslice_Iter; - -template <class _Tp> -class gslice_array { - friend class valarray<_Tp>; -public: - typedef _Tp value_type; - - void operator= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] = __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator*= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] *= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator/= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] /= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator%= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] %= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator+= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] += __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator-= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] -= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator^= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] ^= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator&= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] &= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator|= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] |= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator<<= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] <<= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator>>= (const valarray<value_type>& __x) const { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] >>= __x[__i._M_step]; while(__i._M_incr()); - } - } - - void operator= (const value_type& __c) /*const could be const but standard says NO (26.3.7.4-1)*/ { - if (!_M_gslice._M_empty()) { - _Gslice_Iter __i(_M_gslice); - do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr()); - } - } - - // C++ Standard defect 253, copy constructor must be public. - gslice_array(const gslice_array& __x) - : _M_gslice(__x._M_gslice), _M_array(__x._M_array) - {} - - ~gslice_array() {} - -private: - gslice_array(const gslice &__gslice, valarray<_Tp> &__array) - : _M_gslice(__gslice), _M_array(__array) - {} - - gslice _M_gslice; - valarray<value_type>& _M_array; - -private: - // Disable default constructor and assignment - gslice_array(); - void operator=(const gslice_array<_Tp>&); -}; - -// valarray member functions dealing with gslice and gslice_array. Note -// that it is illegal (behavior is undefined) to construct a gslice_array -// from a degenerate gslice. - -template <class _Tp> -inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __x) - : _Valarray_base<_Tp>(__x._M_gslice._M_size()) { - typedef typename __type_traits<_Tp>::has_trivial_default_constructor - _Is_Trivial; - _M_initialize(_Is_Trivial()); - *this = __x; -} - -template <class _Tp> -inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __slice) -{ return gslice_array<_Tp>(__slice, *this); } - - -//---------------------------------------------------------------------- -// mask_array - -template <class _Tp> -class mask_array { - friend class valarray<_Tp>; -public: - typedef _Tp value_type; - - void operator=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] = __x[__idx++]; - } - - void operator*=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] *= __x[__idx++]; - } - - void operator/=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] /= __x[__idx++]; - } - - void operator%=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] %= __x[__idx++]; - } - - void operator+=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] += __x[__idx++]; - } - - void operator-=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] -= __x[__idx++]; - } - - void operator^=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] ^= __x[__idx++]; - } - - void operator&=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] &= __x[__idx++]; - } - - void operator|=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] |= __x[__idx++]; - } - - void operator<<=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] <<= __x[__idx++]; - } - - void operator>>=(const valarray<value_type>& __x) const { - size_t __idx = 0; - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] >>= __x[__idx++]; - } - - void operator=(const value_type& __c) const { - for (size_t __i = 0; __i < _M_array.size(); ++__i) - if (_M_mask[__i]) _M_array[__i] = __c; - } - - // Extension: number of true values in the mask - size_t _M_num_true() const { - size_t __result = 0; - for (size_t __i = 0; __i < _M_mask.size(); ++__i) - if (_M_mask[__i]) ++__result; - return __result; - } - - // C++ Standard defect 253, copy constructor must be public. - mask_array(const mask_array& __x) - : _M_mask(__x._M_mask), _M_array(__x._M_array) - {} - - ~mask_array() {} - -private: - mask_array(const _Valarray_bool& __mask, valarray<_Tp>& __array) - : _M_mask(__mask), _M_array(__array) - {} - _Valarray_bool _M_mask; - valarray<_Tp>& _M_array; - -private: - // Disable default constructor and assignment - mask_array(); - void operator=(const mask_array<_Tp>&); -}; - -// valarray member functions dealing with mask_array - -template <class _Tp> -inline valarray<_Tp>::valarray(const mask_array<_Tp>& __x) - : _Valarray_base<_Tp>(__x._M_num_true()) { - typedef typename __type_traits<_Tp>::has_trivial_default_constructor - _Is_Trivial; - _M_initialize(_Is_Trivial()); - *this = __x; -} - -// Behavior is undefined if __x._M_num_true() != this->size() -template <class _Tp> -inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __x) { - size_t __idx = 0; - for (size_t __i = 0; __i < __x._M_array.size(); ++__i) - if (__x._M_mask[__i]) (*this)[__idx++] = __x._M_array[__i]; - return *this; -} - -template <class _Tp> -inline mask_array<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) { - _STLP_ASSERT(__mask.size() == this->size()) - return mask_array<_Tp>(__mask, *this); -} - -//---------------------------------------------------------------------- -// indirect_array - -template <class _Tp> -class indirect_array { - friend class valarray<_Tp>; -public: - typedef _Tp value_type; - - void operator=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] = __x[__i]; - } - - void operator*=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] *= __x[__i]; - } - - void operator/=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] /= __x[__i]; - } - - void operator%=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] %= __x[__i]; - } - - void operator+=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] += __x[__i]; - } - - void operator-=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] -= __x[__i]; - } - - void operator^=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] ^= __x[__i]; - } - - void operator&=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] &= __x[__i]; - } - - void operator|=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] |= __x[__i]; - } - - void operator<<=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] <<= __x[__i]; - } - - void operator>>=(const valarray<value_type>& __x) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] >>= __x[__i]; - } - - void operator=(const value_type& __c) const { - for (size_t __i = 0; __i < _M_addr.size(); ++__i) - _M_array[_M_addr[__i]] = __c; - } - - // C++ Standard defect 253, copy constructor must be public. - indirect_array(const indirect_array& __x) - : _M_addr(__x._M_addr), _M_array(__x._M_array) - {} - - ~indirect_array() {} - -private: - indirect_array(const _Valarray_size_t& __addr, valarray<_Tp>& __array) - : _M_addr(__addr), _M_array(__array) - {} - - _Valarray_size_t _M_addr; - valarray<_Tp>& _M_array; - -private: - // Disable default constructor and assignment - indirect_array(); - void operator=(const indirect_array<_Tp>&); -}; - -// valarray member functions dealing with indirect_array - -template <class _Tp> -inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __x) - : _Valarray_base<_Tp>(__x._M_addr.size()) { - typedef typename __type_traits<_Tp>::has_trivial_default_constructor - _Is_Trivial; - _M_initialize(_Is_Trivial()); - *this = __x; -} - - -template <class _Tp> -inline indirect_array<_Tp> -valarray<_Tp>::operator[](const _Valarray_size_t& __addr) -{ return indirect_array<_Tp>(__addr, *this); } - -_STLP_END_NAMESPACE - -# if !defined (_STLP_LINK_TIME_INSTANTIATION) -# include <stl/_valarray.c> -# endif - -#endif /* _STLP_VALARRAY */ - - -// Local Variables: -// mode:C++ -// End: |